IFSP_Curso_Sertaozinho.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "IFSP - Curso Sertaozinho.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMaGHtsdMX0Liib1UFd38mC",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/murilofarias10/AnaliseComPython/blob/main/IFSP_Curso_Sertaozinho.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4_L90kGAAbNT"
      },
      "source": [
        "\n",
        "\n",
        "```\n",
        "# Isto está formatado como código\n",
        "\n",
        "#DESAFIO - Exercito\n",
        "#DESAFIO - Convite de festa\n",
        "#Desafio - Maior e menor valor\n",
        "#DESAFIO - Tratando uma string\n",
        "#Desafio transformar string em lista\n",
        "#Desafio - Calcular media de notas\n",
        "#Desafio dicionarios e looping\n",
        "#Desafio - TRUQUES DE LISTAS\n",
        "#Desafio - Adivinhando proximos 3 numeros\n",
        "#Desafio - Trabalhando com lista maior, menor, media\n",
        "#Desafio - Aplicação para cadastro de doadores de sangue\n",
        "#Desafio - completo notas, medias e aprovação alunos\n",
        "\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BkZ0yrVKbVLu"
      },
      "source": [
        "**Strings**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXKNf39DbjRM"
      },
      "source": [
        "nome = 'aaabbccdd'\n",
        "\n",
        "#nº inicial : ir até : pular\n",
        "print(nome[2:4:2])\n",
        "print(nome[2::4])\n",
        "\n",
        "frase = 'Aprendendo Python'\n",
        "#contando qtde caracteres\n",
        "print(len(frase))\n",
        "#ou\n",
        "contador = len(frase)\n",
        "print(contador)\n",
        "\n",
        "#Utilizando Replace para substituir algo\n",
        "frase = frase.replace('Python', 'Linguagem Python')\n",
        "print(frase)\n",
        "\n",
        "#contando quantos e tem na frase\n",
        "print(frase.count('e'))\n",
        "\n",
        "#localizando onde esta algo\n",
        "print(frase.find('python'))\n",
        "\n",
        "#slit para fazer a divisao\n",
        "print(frase.split())\n",
        "\n",
        "#tudo em maiusculo\n",
        "print(frase.upper())\n",
        "\n",
        "#tudo em minusculo\n",
        "print(frase.lower())\n",
        "\n",
        "#capitalizar, primeira em maiusculo\n",
        "print(frase.capitalize())\n",
        "\n",
        "#primeira letra de cada frase em maiusculo\n",
        "print(frase.title())\n",
        "\n",
        "#o que é maiusculo passa minusculo e vice versa\n",
        "print(frase.swapcase())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BfngtbEiDOhG",
        "outputId": "8f685754-be96-4c93-b96b-b4718e5badd8"
      },
      "source": [
        "frase = '     Aprendendo Python '\n",
        "print(frase)\n",
        "#contando caracteres\n",
        "print(len(frase))\n",
        "\n",
        "#removando espaços antes e apos a frase\n",
        "frase = frase.strip()\n",
        "print(len(frase))\n",
        "\n",
        "#removendo espaços a direita\n",
        "frase = '     Aprendendo Python    '\n",
        "print(frase.rstrip())\n",
        "print(len(frase))\n",
        "frase = '     Aprendendo Python    '\n",
        "print(frase.lstrip())\n",
        "print(len(frase))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "     Aprendendo Python \n",
            "23\n",
            "17\n",
            "     Aprendendo Python\n",
            "26\n",
            "Aprendendo Python    \n",
            "26\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AxRxg_ebtG23",
        "outputId": "2a6d00aa-22d5-4625-8049-c76a21f720cc"
      },
      "source": [
        "frase = '     Aprendendo Python '\n",
        "print(frase)\n",
        "#contando caracteres\n",
        "print(len(frase))\n",
        "\n",
        "#removando espaços antes e apos a frase\n",
        "frase = frase.strip()\n",
        "print(len(frase))\n",
        "\n",
        "#contatenação\n",
        "nome = 'Maria'\n",
        "sobrenome = 'Silva'\n",
        "nomeCompleto = nome +' ' + sobrenome\n",
        "print(nomeCompleto)\n",
        "\n",
        "#Escapando Caracteres \" ou ' \n",
        "string_frase = '''Ola, testando uma string\n",
        "vou utilizar ' ou\" para o armazenamento'''\n",
        "print(string_frase)\n",
        "cantora = \"A cantona Sinner O' cooner\"\n",
        "print(cantora)\n",
        "curso = 'Tenha bastante atenção ao estudar \"Python\"'\n",
        "print(curso)\n",
        "teste = \"Tenha bastante atenção ao estudar \\\"Python\\\"\" #\\\" Texto\\\"\n",
        "print(teste)\n",
        "barra = \"Escapando com \"\"\\ \"\n",
        "print(barra)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "     Aprendendo Python \n",
            "23\n",
            "17\n",
            "Maria Silva\n",
            "Ola, testando uma string\n",
            "vou utilizar ' ou\" para o armazenamento\n",
            "A cantona Sinner O' cooner\n",
            "Tenha bastante atenção ao estudar \"Python\"\n",
            "Tenha bastante atenção ao estudar \"Python\"\n",
            "Escapando com \\ \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ye9kPLmyvV_k",
        "outputId": "571b5d47-13ca-4424-90b5-e1ffcba78fd3"
      },
      "source": [
        "# %s string | %d inteiro | %f decimal\n",
        "nome = 'Fernando'\n",
        "idade = 27\n",
        "print('O nome informado é: %s' %nome)\n",
        "print ('Com idade de %d anos' %idade)\n",
        "print('o nome informado é: ' + nome + ' e ele possui é: ' + str(idade) + ' anos')\n",
        "print('o nome informado é: ' + nome + ' e ele possui ' + 'idade é: {}'.format(idade) + 'anos')\n",
        "print('o nome informado é: ' + nome + 'e ele possui idade é: ' + format(idade) + 'anos')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "O nome informado é: Fernando\n",
            "Com idade de 27 anos\n",
            "o nome informado é: Fernando e ele possui é: 27 anos\n",
            "o nome informado é: Fernando e ele possui idade é: 27anos\n",
            "o nome informado é: Fernandoe ele possui idade é: 27anos\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pern--ocwdRr"
      },
      "source": [
        "raio = 30.46257\n",
        "print('Formatando decimais: %f' %raio)\n",
        "print('Formatando decimais: %.2f' %raio)\n",
        "print('Formatando decimais: %.3f' %raio)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7nF6V6Iyxxj6",
        "outputId": "e2f61407-364f-4e13-c1fb-4ee8a740d3cc"
      },
      "source": [
        "#utilizando o r na frente\n",
        "teste = r\"utilizamos \\n \"\n",
        "teste2 = r'utlizamos \"\\n\"'\n",
        "print(teste)\n",
        "print(teste2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "utilizamos \\n \n",
            "utlizamos \"\\n\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ax5rOW119Sop",
        "outputId": "74406872-1efe-46c0-be8b-afd9dce20d01"
      },
      "source": [
        "#centralizando e colocando caracteres\n",
        "documento = 'ola meu nome é murilo'\n",
        "print(documento.center(50, \"*\"))\n",
        "#preenchendo somente a direita e a esquerda\n",
        "print(documento.ljust(50, \"*\"))\n",
        "print(documento.rjust(50, \"*\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "**************ola meu nome é murilo***************\n",
            "ola meu nome é murilo*****************************\n",
            "*****************************ola meu nome é murilo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GwsXoQ7tAvxX",
        "outputId": "6c7cd553-85ad-4ac6-dc95-9004fccf92ef"
      },
      "source": [
        "#isalnum (ambos), isalpha (somente letra) e isnumeric (somente numero)\n",
        "\n",
        "validacao = 'murilo'\n",
        "valida = '12345'\n",
        "dois = 'Murilo123'\n",
        "\n",
        "print(validacao.isalnum()) #true\n",
        "print(validacao.isalpha()) #true\n",
        "print(validacao.isnumeric()) #false\n",
        "\n",
        "print(valida.isalnum()) #true\n",
        "print(valida.isalpha()) #false\n",
        "print(valida.isnumeric()) # true\n",
        "\n",
        "print(dois.isalnum()) #true\n",
        "print(dois.isalpha()) #false\n",
        "print(dois.isnumeric()) # false"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n",
            "False\n",
            "True\n",
            "False\n",
            "True\n",
            "True\n",
            "False\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3m5nPjKtIUp0"
      },
      "source": [
        "#imprimindo lista com ordem ao contraria\n",
        "mista = ['Murilo', 'Thamie', 'Briane', 15, 18, 'Caio']\n",
        "print(mista)\n",
        "print(mista[-3])\n",
        "\n",
        "#alterar valor\n",
        "\n",
        "mista[3] = 5\n",
        "print(mista)\n",
        "\n",
        "#append para adicionar um item ao final\n",
        "mista.append('Teste')\n",
        "print(mista)\n",
        "\n",
        "#insert insere em alguma posição\n",
        "mista.insert(1, \"Roberto\")\n",
        "print(mista)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_fqMYlZrLNsA",
        "outputId": "425b8144-553e-4ea8-d5ea-391a7779cfdf"
      },
      "source": [
        "#Função extend unifica as listas\n",
        "mista = ['Murilo', 'Thamie', 'Briane', 15, 18, 'Caio']\n",
        "marte = [1,2,3,4,5]\n",
        "\n",
        "print(mista)\n",
        "print(marte)\n",
        "\n",
        "marte.extend(mista)\n",
        "print(marte)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Murilo', 'Thamie', 'Briane', 15, 18, 'Caio']\n",
            "[1, 2, 3, 4, 5]\n",
            "[1, 2, 3, 4, 5, 'Murilo', 'Thamie', 'Briane', 15, 18, 'Caio']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ET_5M9tfNxoN",
        "outputId": "622fbf25-4342-469f-c8b0-a825ea7600b6"
      },
      "source": [
        "#removendo item de uma lista\n",
        "#remove para remover um item especifico\n",
        "print(marte)\n",
        "marte.remove('Briane')\n",
        "print(marte)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 'Murilo', 'Thamie', 'Briane', 15, 18, 'Caio']\n",
            "[1, 2, 3, 4, 5, 'Murilo', 'Thamie', 15, 18, 'Caio']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S8pnqTKOPlcM",
        "outputId": "4af8d43a-cafc-4701-dcfb-90c2eee32fb5"
      },
      "source": [
        "#função POP para remover de um item especifico\n",
        "nova_lista = ['Ronnan', 'Maico', 'Murilo', 'Tiago']\n",
        "print(nova_lista)\n",
        "\n",
        "nova_removido = nova_lista.pop(0)\n",
        "print(nova_removido)  \n",
        "print(nova_removido)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Ronnan', 'Maico', 'Murilo', 'Tiago']\n",
            "Ronnan\n",
            "Ronnan\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xh18nb0cS-GU",
        "outputId": "ecad47e3-f082-40be-8d4d-75aac17bb521"
      },
      "source": [
        "valor = 'murilo'\n",
        "aluno = 'murilo'\n",
        "frase = 'Aprendendo Python com o IFSP'\n",
        "\n",
        "print(frase[11:17])\n",
        "\n",
        "print(valor.upper())\n",
        "print(len(aluno))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Python\n",
            "MURILO\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DYciOGjAT8jN",
        "outputId": "520f0901-a60c-4a14-99d2-8df78a419917"
      },
      "source": [
        "#forma errada para backup\n",
        "alunos = ['jose', 'joao', 'luiz']\n",
        "alunos_backup = alunos\n",
        "print(alunos_backup)\n",
        "alunos.clear()\n",
        "print('apos o clear {}'.format(alunos_backup))\n",
        "\n",
        "#forma correta | utilizando o copy\n",
        "alunos = ['jose', 'joao', 'luiz']\n",
        "alunos_backup = alunos.copy()\n",
        "print(alunos_backup)\n",
        "alunos.clear()\n",
        "print(alunos_backup)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['jose', 'joao', 'luiz']\n",
            "apos o clear []\n",
            "['jose', 'joao', 'luiz']\n",
            "['jose', 'joao', 'luiz']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WopECcREiOse"
      },
      "source": [
        "#DESAFIO - Exercito\n",
        "\n",
        "#Faça um programa que pergunta a idade\n",
        "#o peso e a altura e decide se esta APTO a ser do Exercito\n",
        "#Para entrar no exercito é preciso ter mais de 18 pesar mais ou igual 60 Kg e medir mais ou igual 1.7\n",
        "idade = int(input('Qual sua idade ?'))\n",
        "peso = float(input('Qual seu peso ?'))\n",
        "altura = float(input('Qual sua altura'))\n",
        "\n",
        "if idade > 18 and peso >= 60 and altura >=1.7:\n",
        "  print('APTO ao exercito')\n",
        "\n",
        "else:\n",
        "  print('NAO APTO')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ezi9zZODWazy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7370db04-4d4c-4e03-e4c9-025a6caf3609"
      },
      "source": [
        "#DESAFIO - Convite de festa\n",
        "\n",
        "#Faça um programa que leia a quantidade de pessoas que serão convidados para uma festa\n",
        "#Após isso o programa ira pergunta o nome de todos as pessoas e colocar \n",
        "#numa lista de convidados e imprimir todos os nomes da lista\n",
        "pessoas = int(input('Quantidade de pessoas para a festa ?'))\n",
        "\n",
        "contador = pessoas\n",
        "inicial = 0\n",
        "lista_convidados = []\n",
        "\n",
        "while inicial < contador:\n",
        "  convidado = str(input('Digite nome da pessoa:'))\n",
        "  lista_convidados.append(convidado)\n",
        "  inicial = inicial + 1\n",
        "#print('sua lista de convidados é:{}'.format(lista_convidados))\n",
        "\n",
        "for x in lista_convidados:\n",
        "  n= lista_convidados.index(x)+1\n",
        "  print(str(n) + ' Convidado nome:'+ x)\n",
        "  \n",
        "  "
      ],
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Quantidade de pessoas para a festa ?3\n",
            "Digite nome da pessoa:murilo\n",
            "Digite nome da pessoa:maico\n",
            "Digite nome da pessoa:leticia\n",
            "1 Convidado nome:murilo\n",
            "2 Convidado nome:maico\n",
            "3 Convidado nome:leticia\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Acf7_3qSqVA5"
      },
      "source": [
        "#verifique se o nome do usuario começa com M\n",
        "nome = str(input('Digite seu nome'))\n",
        "\n",
        "if nome[0].upper() == 'M':\n",
        "  print('OK')\n",
        "  print('1ª letra digitado: ' + nome[0].upper())\n",
        "else:\n",
        "  print('NOK')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-4VtORzCnwB1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a91dfd30-7c67-4809-f1d0-5dae27e819af"
      },
      "source": [
        "#Desafio - Maior e menor valor\n",
        "\n",
        "#Escreva função que recebe objeto de coleção e retorna o valor do maior numero dentro da\n",
        "#coleção e retorna o menor numero\n",
        "print(\"Inicio\")\n",
        "\n",
        "lista = []\n",
        "inicio = 1\n",
        "fim = 4\n",
        "while inicio < fim:\n",
        "  valores = int(input('Digite ' + str(inicio)  + ' numero: \\n'))\n",
        "  print('\\n')\n",
        "  lista.append(valores)\n",
        "  inicio = inicio + 1\n",
        "print('\\n')\n",
        "print('Menor valor digitado é: {}\\n'.format(min(lista)))\n",
        "print('Maior valor digitado é: {}\\n'.format(max(lista)))\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Inicio\n",
            "Digite 1 numero: \n",
            "45\n",
            "\n",
            "\n",
            "Digite 2 numero: \n",
            "20\n",
            "\n",
            "\n",
            "Digite 3 numero: \n",
            "50\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "Menor valor digitado é: 20\n",
            "\n",
            "Maior valor digitado é: 50\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QJyTlik1Cy0L"
      },
      "source": [
        "nome = input('Digite seu nome: ')\n",
        "idade = input('Digite sua idade: ')\n",
        "print('seu nome é ' + nome+ ' sua idade é ' + idade)\n",
        "print('quantidade ' + str(len(nome)) + ' caracteres ')\n",
        "print('Duas primeiras letras é: ' + nome[0:2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Nz1gF3qEFKE"
      },
      "source": [
        "#Solicite ao usuario informe seu nome\n",
        "#verifique se existe a palavra jose em qualquer parte do nome\n",
        "\n",
        "nome = str(input('Digite seu nome completo'))\n",
        "verificacao = 'JOSE'\n",
        "nome_ver = nome.upper()\n",
        "\n",
        "if nome_ver.find(verificacao, 0) > -1:\n",
        "  print('Seu nome contem: ' + str(verificacao))\n",
        "else:\n",
        "  print('Seu nome não contem: ' + str(verificacao))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Q7sYqu4xNvi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9de8e29e-00f7-45cb-d941-721e68d6a942"
      },
      "source": [
        "#DESAFIO - Tratando uma string\n",
        "\n",
        "#Solicite ao usuario uma frase\n",
        "#motrar frase em minusculo\n",
        "#mostrar frase em maiusculo\n",
        "#contar quantidade de caracteres sem os espaços\n",
        "#contar quantidade de caracteres com os espaços\n",
        "\n",
        "frase = str(input('Digite uma frase: '))\n",
        "frase_maiusculo = frase.upper()\n",
        "frase_minusculo = frase.lower()\n",
        "print('\\n')\n",
        "print('frase_minusculo é:' + frase_minusculo)\n",
        "print('\\n')\n",
        "print('frase_maiusculo é:' + frase_maiusculo)\n",
        "\n",
        "frase_sem_espaco = frase.replace(' ', '')\n",
        "\n",
        "com_espaco = (len(frase))\n",
        "conta_caracteres = (len(frase_sem_espaco))\n",
        "print('\\n')\n",
        "print('Total de letras da frase sem espaço: ' + str(conta_caracteres))\n",
        "print('\\n')\n",
        "print('Total de letras da frase com espaço: ' + str(com_espaco))"
      ],
      "execution_count": 147,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite uma frase: murilo estuda python\n",
            "\n",
            "\n",
            "frase_minusculo é:murilo estuda python\n",
            "\n",
            "\n",
            "frase_maiusculo é:MURILO ESTUDA PYTHON\n",
            "\n",
            "\n",
            "Total de letras da frase sem espaço: 18\n",
            "\n",
            "\n",
            "Total de letras da frase com espaço: 20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zr7-QVLc32Iq"
      },
      "source": [
        "#PROFESSOR\n",
        "#Solicite ao usuario uma frase\n",
        "#motrar frase em minusculo\n",
        "#mostrar frase em maiusculo\n",
        "#contar quantidade de caracteres sem os espaços\n",
        "#contar quantidade de caracteres com os espaços\n",
        "\n",
        "\n",
        "frase = input('Uma frase')\n",
        "\n",
        "print('frase maisculo: ' + frase.upper())\n",
        "print('frase minusculo: ' + frase.lower())\n",
        "print('qtde total caracteres: ' + str(len(frase)))\n",
        "print('qtde caracteres sem espaço: ' +str(len(frase) - frase.count(' ')))\n",
        "print('qtde espaço: ' + str(frase.count(' ')))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YsE4vmKhoRlC"
      },
      "source": [
        "# expressão regular https://regex101.com/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gQgapgWeBRJe",
        "outputId": "e80d3348-43ab-4c36-ea20-19da2a9dbb8a"
      },
      "source": [
        "#Desafio transformar string em lista\n",
        "\n",
        "#utilização do comando SPLIT\n",
        "#transforma em uma string em uma lista de acordo com os caracteres passados\n",
        "\n",
        "nome = input(\"Digite aqui o seu nome completo: \")\n",
        "teste= nome.split(\"i\")\n",
        "print(teste)\n",
        "print(\"Primeiro nome: \" + teste[0])\n",
        "print(\"Segundo nome: \" + teste[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite aqui o seu nome completo: murilo farias\n",
            "['mur', 'lo far', 'as']\n",
            "Primeiro nome: mur\n",
            "Segundo nome: lo far\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DT4-7lBxOmE7"
      },
      "source": [
        "#Utilizando um API para buscar informações em um site\n",
        "#Importando bibliotecas\n",
        "import requests\n",
        "import json\n",
        "import time\n",
        "import datetime\n",
        "\n",
        "#identificando o site\n",
        "url='https://economia.awesomeapi.com.br/last/USD-BRL,EUR-BRL,BTC-BRL'\n",
        "\n",
        "while True:\n",
        "  time.sleep(3)\n",
        "  requisicao = requests.get(url)\n",
        "\n",
        "  cotacao = json.loads(requisicao.text)\n",
        "\n",
        "  print('Moeda: ' + cotacao['USDBRL']['bid'])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9b7oPagyVO4e"
      },
      "source": [
        "#Utilizando um API para buscar informações em um site\n",
        "#consulta clima tempo #digitando nome da cidade\n",
        "import requests\n",
        "import json\n",
        "import time\n",
        "\n",
        "cidade = str(input('Digite nome da cidade: '))\n",
        "print('\\n')\n",
        "while True:\n",
        "  requisicao = requests.get('https://api.hgbrasil.com/weather?array_limit=2&fields=only_results,temp,'+ str(cidade) +',forecast,max,min,date&key=18420e13')\n",
        "\n",
        "  busca = json.loads(requisicao.text)  \n",
        "  \n",
        "  informacoes = str((busca['forecast']))\n",
        "  \n",
        "  novo = informacoes.split(\",\")\n",
        "\n",
        "  data = novo[0]\n",
        "\n",
        "  \n",
        "  valor_max = novo[1]\n",
        "  valor_min = novo[2]\n",
        "  \n",
        "  data_novo = data.replace(\"[{'date':\", \"\")\n",
        "\n",
        "  novo_valor_max = valor_max.replace(\"'max':\", \"\")\n",
        "  novo_valor_min = valor_min.replace(\"'min':\", \"\")\n",
        "\n",
        "  novo_valor_min_b = novo_valor_min.replace(\"}\", \"\")\n",
        "  data_novo_b = data_novo.replace(\"'\", \"\")\n",
        "\n",
        "  print('Cidade Pesquisada: ' + cidade)\n",
        "  print('Temperatura Atual: ' + str(busca[\"temp\"])) \n",
        "  print('Data de hoje: ' + data_novo_b)\n",
        "  print('Temperatura maxima: ' + novo_valor_max)\n",
        "  print('Temperatura minima: ' + novo_valor_min_b)\n",
        "\n",
        "  time.sleep(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OLBcDQZe9Jsd"
      },
      "source": [
        "#Informe um valor qualquer e verifique se é maior do que 100\n",
        "\n",
        "valor = int(input('Digite um valor qualquer: '))\n",
        "\n",
        "if valor > 100:\n",
        "  print('valor:', valor, ' é maior do que 100')\n",
        "\n",
        "else:\n",
        "  print('valor:', valor, ' não é maior do que 100')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HmyDgnUbAzJ1"
      },
      "source": [
        "#pessoa deve ser maior ou igual a 18 e for do sexo masculino deve ter reservista\n",
        "\n",
        "sexo = input('Digite sexo M ou F: ')\n",
        "\n",
        "if sexo.upper() == 'F':\n",
        "  print('Sexo feminino não possui reservista')\n",
        "\n",
        "elif sexo.upper() =='M':\n",
        "  idade = int(input('Digite sua idade'))\n",
        "  \n",
        "  if idade>=18:\n",
        "    print('Voce ja tem reservista')\n",
        "\n",
        "  else:\n",
        "    print('Voce ainda não tem reservista')\n",
        "\n",
        "  \n",
        "\n",
        "\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C2pWiME2GUNt",
        "outputId": "5f95a779-5088-4a66-d35a-6005b869be97"
      },
      "source": [
        "#verificar tipo sanguineo , caso seja A ou O é um possivel doador\n",
        "tipo_sanguineo = str(input('Digite seu tipo sanguineo: '))\n",
        "\n",
        "if tipo_sanguineo.upper() == 'A' or tipo_sanguineo.upper() =='O':\n",
        "  print('Você é um possivel doador')\n",
        "else:\n",
        "  print('Você não é um possível dodor')\n",
        "\n",
        "print('tipo sanguineo informado foi: ', tipo_sanguineo.upper())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite seu tipo sanguineo: a\n",
            "Você é um possivel doador\n",
            "tipo sanguineo informado foi:  A\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "edVlQQw1Jv7l"
      },
      "source": [
        "#Desafio - Calcular media de notas\n",
        "\n",
        "#Solicitar 3 notas\n",
        "#Calcular media \n",
        "#Se media for abaixo de 6 reprovado\n",
        "#Se media for igual ou superior a 6 aprovado\n",
        "\n",
        "quantidade = 3\n",
        "inicio = 0\n",
        " \n",
        "lista = []\n",
        "while inicio < quantidade:\n",
        "  aparecer_no_texto = inicio +1\n",
        "  nota = int(input('Digite sua '+ str(aparecer_no_texto) + 'ª nota: '))\n",
        "\n",
        "  if nota<0 or nota>10:\n",
        "    print('nota digitada incorretamente')\n",
        "\n",
        "  else:\n",
        "    lista.append(nota)\n",
        "    inicio = inicio + 1\n",
        "\n",
        "nome_aluno = str(input('Digite nome do aluno: '))\n",
        "media = (lista[0] + lista[1] + lista[2]) / 3\n",
        "\n",
        "if media >= 6:\n",
        "  print(nome_aluno.upper(), 'Você foi APROVADO, sua média é:', media)\n",
        "\n",
        "else:\n",
        "  print(nome_aluno.upper(), 'voce foi REPROVADO, sua média é:', media, '\\n obs:media necessaria para passar é maior ou igual a 6')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kyzfyfaTRj3h"
      },
      "source": [
        "#solicite o peso de duas pessoas \n",
        "#verifique qual pessoa é mais pesada\n",
        "\n",
        "print('iniciando verificação')\n",
        "pessoa_1 = int(input('Digite o peso da primeira pessoa: '))\n",
        "pessoa_2 = int(input('Digite o peso da segunda pessoa: '))\n",
        "\n",
        "print('\\n')\n",
        "if pessoa_1 > pessoa_2:\n",
        "  print('primeira pessoa é mais pesada do que a segunda pessoa \\n peso primeira pessoa: ', pessoa_1, '\\n peso da segunda pessoa: ', pessoa_2)\n",
        "\n",
        "elif pessoa_2 > pessoa_1:\n",
        "  print('segunda pessoa é mais pesada do que a primeira \\n peso segunnda pessoa: ', pessoa_2, '\\n peso da primeira pessoa: ', pessoa_1)\n",
        "\n",
        "else:\n",
        "  print('As duas pessoas tem o mesmo peso')\n",
        "\n",
        "print('\\n')\n",
        "print('fim da verificação')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rAMeVEv2eHVv"
      },
      "source": [
        "#solicitar 2 valores\n",
        "#fazer a potencia e verificar se é par ou impar\n",
        "\n",
        "valor_1 = int(input('Digite o primeiro valor'))\n",
        "valor_2 = int(input('Digite o segundo valor'))\n",
        "\n",
        "#** significa elevado\n",
        "total = valor_1 ** valor_2\n",
        "\n",
        "#quando o resto da divisão é = 0 então o numero é par\n",
        "#quando o resto da divisão é = 1 então o numero é impart\n",
        "resto = total % 2\n",
        "\n",
        "if resto == 0:\n",
        "  print('valor par', total)\n",
        "\n",
        "else:\n",
        "  print('valor impar', total)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xmmHjqZACFYP"
      },
      "source": [
        "#leitura de pesos\n",
        "#Ler 3 nome e seus respectivos pesos\n",
        "#Mostrar do mais pesado para o mais leve\n",
        "\n",
        "print('Inicio da aplicação')\n",
        "nome_1 = str(input('Digite seu nome: '))\n",
        "peso_1 = int(input('Digite seu peso: '))\n",
        "\n",
        "nome_2 = str(input('Digite seu nome: '))\n",
        "peso_2 = int(input('Digite seu peso: '))\n",
        "\n",
        "nome_3 = str(input('Digite seu nome: '))\n",
        "peso_3 = int(input('Digite seu peso: '))\n",
        "\n",
        "if peso_1 > peso_2 and peso_1 > peso_3:\n",
        "  print('O nome do mais pesado é: ',nome_1,'(',peso_1,')')\n",
        "  if peso_2 > peso_3:\n",
        "    print('O nome do segundo mais pesado é: ', nome_2, '(',peso_2,')', '\\ne o terceiro mais pesado é: ', nome_3, '(',peso_3,')')\n",
        "  else:\n",
        "    print('O nome do segundo mais pesado é: ', nome_3,'(',peso_3,')','\\ne o terceiro mais pesado é: ', nome_2,'(',peso_2,')')\n",
        "\n",
        "elif peso_2>peso_1 and peso_2>peso_3:\n",
        "  print('o nome do mais pesado é: ',nome_2,'(',peso_2,')')\n",
        "  if peso_1>peso_3:\n",
        "    print('o nome do segundo mais pesado é: ', nome_1, '(',peso_1,')','\\ne o terceiro mais pesado é: ',nome_3,'(',peso_3,')')\n",
        "  else:\n",
        "    print('o nome do segundo mais pesado é: ', nome_3, '(',peso_3,')','\\ne o terceiro mais pesado é: ',nome_1,'(',peso_1,')')\n",
        "\n",
        "else:\n",
        "  #peso_3>peso_1 and peso_3 > peso_2:\n",
        "  print('o nome do mais pesado é: ',nome_3,'(',peso_3,')')\n",
        "  if peso_1>peso_2:\n",
        "    print('o nome do segundo mais pesado é: ', nome_1, '(',peso_1,')','\\ne o terceiro mais pesado é: ',nome_2,'(',peso_2,')')\n",
        "  else:\n",
        "    print('o nome do segundo mais pesado é: ', nome_2, '(',peso_2,')','\\ne o terceiro mais pesado é: ',nome_1,'(',peso_1,')')\n",
        "\n",
        "print('Fim do processamento')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-htw4-hrR-03",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ab75bb9-c141-4ea8-f926-fb998923c281"
      },
      "source": [
        "#Desafio dicionarios e looping\n",
        "\n",
        "#LOOPS FOR COM LISTA\n",
        "aluno ={'Nome': 'Maria', 'idade':20, 'nota': 9.2}\n",
        "for chave in aluno: #chaves: Nome, Idade, Nota\n",
        "  print(chave)\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "aluno ={'Nome': 'Maria', 'idade':20, 'nota': 9.2}\n",
        "for chave in aluno.keys(): #keys: Nome, Idade, nota\n",
        "  print(chave)\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "aluno ={'Nome': 'Maria', 'idade':20, 'nota': 9.2}\n",
        "for chave in aluno.values(): #values: Maria, 20, 9.2\n",
        "  print(chave)\n",
        "\n",
        "#Completo\n",
        "\n",
        "print('\\n')\n",
        "aluno ={'Nome': 'Maria', 'idade':20, 'nota': 9.2}\n",
        "for chave, valor in aluno.items():\n",
        "  print(chave,'-',(valor))\n",
        "\n"
      ],
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nome\n",
            "idade\n",
            "nota\n",
            "\n",
            "\n",
            "Nome\n",
            "idade\n",
            "nota\n",
            "\n",
            "\n",
            "Maria\n",
            "20\n",
            "9.2\n",
            "\n",
            "\n",
            "Nome - Maria\n",
            "idade - 20\n",
            "nota - 9.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W3lFE_eRTMEW"
      },
      "source": [
        "#Utilização do RANGE\n",
        "for i in range(5): #começa no zero e termina excluindo o valor informado\n",
        "  print(i)\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "for i in range(1,11): #começa no primeiro e termina excluindo o  valor informado\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mQA5kPHmTRqU"
      },
      "source": [
        "#utlização do BREAK e CONTINUE\n",
        "print('Exemplo do BREAk')\n",
        "for i in range(1,11):\n",
        "  if i % 5 ==0:\n",
        "    break\n",
        "  print(i)\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "for i in range(1,11):\n",
        "  if i % 5 ==0:\n",
        "    continue\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ygZdDV2VWA-g"
      },
      "source": [
        "#LOOPS WHILE TRUE\n",
        "while True:\n",
        "  letra_digitada = input('Digite seu nome para sair:')\n",
        " \n",
        "  if letra_digitada.upper() == 'MURILO':\n",
        "    break \n",
        "  else:\n",
        "    print('Tente novamente')\n",
        "  \n",
        "print('voce saiu')\n",
        "  \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rv4cCP0OTa7X",
        "outputId": "6ed13263-d983-490d-8f3e-00d3ec792653"
      },
      "source": [
        "#Desafio - TRUQUES DE LISTAS\n",
        "\n",
        "#PRIMEIRO  [0, 0]\n",
        "teste = [0 for i in range(2)]\n",
        "print('Prmeiro: ', teste)\n",
        "\n",
        "#SEGUNDO  [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n",
        "matriz = [ [0 for i in range(4)] for j in range(4)]\n",
        "print('Segundo: ',matriz)\n",
        "\n",
        "#TERCEIRO [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]\n",
        "inicio=1\n",
        "\n",
        "for linha in range(4):\n",
        "    for coluna in range(4):\n",
        "        matriz[linha][coluna] = inicio\n",
        "        #inicio += 1\n",
        "        inicio = inicio +1\n",
        "print('Terceiro:', matriz)\n",
        "\n",
        "'''\n",
        "#QUARTO \n",
        "         1         2         3         4\n",
        "         5         6         7         8\n",
        "         9        10        11        12\n",
        "        13        14        15        16\n",
        "'''\n",
        "print('Quarto: ')\n",
        "for linha in range(4):\n",
        "  for coluna in range(4):\n",
        "    print(\"%10d\" % matriz[linha][coluna], end='')     \n",
        "  print()\n",
        "    \n",
        "print('Quinto')\n",
        "for linha in range(2):\n",
        "  for coluna in range(2):\n",
        "    valor = matriz[linha][coluna] \n",
        "    print(valor)"
      ],
      "execution_count": 150,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Prmeiro:  [0, 0]\n",
            "Segundo:  [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]\n",
            "Terceiro: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]\n",
            "Quarto: \n",
            "         1         2         3         4\n",
            "         5         6         7         8\n",
            "         9        10        11        12\n",
            "        13        14        15        16\n",
            "Quinto\n",
            "1\n",
            "2\n",
            "5\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "05eoCknEMG8_",
        "outputId": "1a03efa9-572b-4e24-f5b3-932ad143f5a9"
      },
      "source": [
        "valor = range(2)\n",
        "print(valor)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "range(0, 5)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eBJGInC0EvPj",
        "outputId": "4c3cbad1-313d-4883-80a2-525c87151f61"
      },
      "source": [
        "#Desafio - Adivinhando proximos 3 numeros\n",
        "\n",
        "#Condição de repetição\n",
        "#Faça uma aplicação que receba um numero e mostre os proximos 3 numeros\n",
        "\n",
        "inicial = int(input('Digite um numero: '))\n",
        "final = inicial + 3\n",
        "print('Numero informado: ', inicial)\n",
        "\n",
        "while inicial < final:\n",
        "  inicial+=1\n",
        "  print('Proximo é: ', inicial)\n",
        "  \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Numero informado:  10\n",
            "Proximo é:  11\n",
            "Proximo é:  12\n",
            "Proximo é:  13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WeQKCJE1Ot8x"
      },
      "source": [
        "#Faça uma aplicação que receba o nome e o sexo de uma pessoa.\n",
        "#Sendo no sexo o valor M para masculino e F para feminino\n",
        "#Ao final apresente o nome e o  sexo da pessoa\n",
        "\n",
        "nome = input('Digite o nome da pessoa: ')\n",
        "sexo = str(input('Digite o sexo M/F: '))\n",
        "\n",
        "while sexo.upper() != 'F' and  sexo.upper() != 'M':\n",
        "  print('sexo digitado incorretamente')\n",
        "  print('digite novamente o sexo M/F')\n",
        "  sexo = str(input('Digite o sexo M/F: '))\n",
        "  \n",
        "if sexo.upper() =='M':\n",
        "    print('o sexo da pessoa: ', nome, 'é: MASCULINO')\n",
        "  \n",
        "elif sexo.upper() =='F':\n",
        "    print('o sexo da pessoa: ', nome, 'é: FEMININO')\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tIkAvbFJeM6P",
        "outputId": "1085b31f-210b-42f0-cf78-d687d82144c4"
      },
      "source": [
        "#faça uma aplicação que tenha uma estrutura de repetição que fique solicitando uma \n",
        "#palavra ao usuario \n",
        "#até que o usuario informe que o programa deve encerrar\n",
        "#Apos a finalização da aplicação apresente ao usuario o numero de palavras que ele inseriu no sistema\n",
        "\n",
        "finalizar = str(input('Digite seu nome para finalizar: '))\n",
        "tentativa = 1\n",
        "\n",
        "while finalizar.upper() != 'MURILO':\n",
        "  print('quantidade total de tentativas até o momento: ', tentativa)\n",
        "  finalizar = str(input('Digite seu nome para finalizar'))\n",
        "  tentativa +=1\n",
        "\n",
        "tentativa = tentativa -1\n",
        "print('Voce saiu', finalizar, ' com quantidade de tentativas', tentativa)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite seu nome para finalizar: m\n",
            "quantidade total de tentativas até o momento:  1\n",
            "Digite seu nome para finalizarfa\n",
            "quantidade total de tentativas até o momento:  2\n",
            "Digite seu nome para finalizarmurilo\n",
            "Voce saiu murilo  com quantidade de tentativas 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kCeS4aMYhV0z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df4b65f2-880c-44ac-b1cf-400d6584f4c9"
      },
      "source": [
        "#contador de palavras até que o usuario informe que deseja encerrar\n",
        "\n",
        "palavras_total = 0\n",
        "\n",
        "print('Iniciando o programa')\n",
        "alternativa = str(input('Deseja informar uma palavra ? S/N:'))\n",
        "\n",
        "while alternativa.upper() != 'S' and alternativa.upper() != 'N':\n",
        "  print('alternativa incorreta, digite novamente')\n",
        "  alternativa = str(input('Deseja informar uma palavra ? S/N:'))\n",
        "\n",
        "while alternativa.upper() == 'S':\n",
        "  palavra = input('Informe uma palavra: ')\n",
        "  palavras_total +=1\n",
        "  alternativa = str(input('Deseja informar outra palavra ? S/N:'))\n",
        "\n",
        "  while alternativa.upper() != 'S' and alternativa.upper() != 'N':\n",
        "    print('alternativa incorreta, digite novamente')\n",
        "    alternativa = str(input('Deseja informar uma palavra ? S/N:'))\n",
        "\n",
        "  \n",
        "\n",
        "print('\\n')\n",
        "print('Finalizando o sistema, \\n Você informou um total de : ', palavras_total, ' palavras')\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iniciando o programa\n",
            "Deseja informar uma palavra ? S/N:s\n",
            "Informe uma palavra: murilo farias\n",
            "Deseja informar outra palavra ? S/N:n\n",
            "\n",
            "\n",
            "Finalizando o sistema, \n",
            " Você informou um total de :  1  palavras\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FMMpoDZ_yseB",
        "outputId": "74b7e340-93e7-466b-9888-cfd9f4bfb012"
      },
      "source": [
        "#Desafio - Trabalhando com lista maior, menor, media\n",
        "\n",
        "#escreva um programa que solicita 10 numeros ao usuario\n",
        "#atraves de um laço while e ao final mostre\n",
        "#qual destes numeros é o maior\n",
        "#qual deste numeros é o menor\n",
        "#qual é a media dos numeros\n",
        "\n",
        "inicio = 1\n",
        "final = 10\n",
        "lista = []\n",
        "print('\\n iniciando sistema - Digite 10 valores: \\n')\n",
        "\n",
        "while inicio <= final:\n",
        "  numero = input(('digite '+ str(inicio)+ 'º valor: '))\n",
        "  inicio = inicio +1\n",
        "  lista.append(numero)\n",
        "\n",
        "valor1 = int(lista[0])\n",
        "valor2 = int(lista[1])\n",
        "valor3 = int(lista[2])\n",
        "valor4 = int(lista[3])\n",
        "valor5 = int(lista[4])\n",
        "valor6 = int(lista[5])\n",
        "valor7 = int(lista[6])\n",
        "valor8 = int(lista[7])\n",
        "valor9 = int(lista[8])\n",
        "valor10 = int(lista[9])\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "maior = max(lista, key=int)\n",
        "menor = min(lista)\n",
        "media = str((valor1 + valor2 + valor3 + valor4 + valor5 + valor6+ valor7+valor8+valor9+valor10) / 10)\n",
        "\n",
        "print('O maior valor digitado é: ',maior, 'posicao: ' , lista.index(maior))\n",
        "\n",
        "print('O menor valor digitado é: ', menor, 'posicao: ', lista.index(menor))\n",
        "\n",
        "print('A media é:',media)\n",
        "\n",
        "print('Lista completa: ',lista)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            " iniciando sistema - Digite 10 valores: \n",
            "\n",
            "digite 1º valor: 6\n",
            "digite 2º valor: 4\n",
            "digite 3º valor: 55\n",
            "digite 4º valor: 2\n",
            "digite 5º valor: 1\n",
            "digite 6º valor: 80\n",
            "digite 7º valor: 3\n",
            "digite 8º valor: 4\n",
            "digite 9º valor: 5\n",
            "digite 10º valor: 500\n",
            "\n",
            "\n",
            "O maior valor digitado é:  500 posicao:  9\n",
            "O menor valor digitado é:  1 posicao:  4\n",
            "A media é: 66.0\n",
            "Lista completa:  ['6', '4', '55', '2', '1', '80', '3', '4', '5', '500']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D9CFzbmE1g4O",
        "outputId": "f6741ed5-120e-4806-d1ba-b6da1f04fe86"
      },
      "source": [
        "#Solicite ao usuario para digitar 10 numeros\n",
        "#Verifique qual maior numero\n",
        "#Verifique qual o menor numero\n",
        "#faça a media dos numeros\n",
        "\n",
        "quantidade = 1\n",
        "somatorio = 0\n",
        "\n",
        "while quantidade <= 10:\n",
        "  numero = int(input('Informe ' + str(quantidade) + 'º numero : '))\n",
        "\n",
        "  if quantidade ==1:\n",
        "    maior = numero\n",
        "    menor = numero\n",
        "  elif (numero>maior):\n",
        "    maior= numero\n",
        "  elif (numero<menor):\n",
        "    menor = numero\n",
        "\n",
        "  somatorio = somatorio + numero\n",
        "  quantidade = quantidade + 1\n",
        "\n",
        "else:\n",
        "  media = somatorio / 10\n",
        "\n",
        "print('O maior valor é: ', maior)\n",
        "print('O menor valor é: ',  menor)\n",
        "print('Media é: ', media)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Informe 1º numero : 1\n",
            "Informe 2º numero : 2\n",
            "Informe 3º numero : 3\n",
            "Informe 4º numero : 4\n",
            "Informe 5º numero : 5\n",
            "Informe 6º numero : 6\n",
            "Informe 7º numero : 7\n",
            "Informe 8º numero : 8\n",
            "Informe 9º numero : 9\n",
            "Informe 10º numero : 10\n",
            "O maior valor é:  10\n",
            "O menor valor é:  1\n",
            "Media é:  5.5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Trx0Ki6MSYEE",
        "outputId": "77890a97-5da8-47bd-8bab-b5f4c2d6a1e8"
      },
      "source": [
        "#utilizando o conceito de FOR faça uma aplicação que mostre os numeros \n",
        "#pares na sequencia numerica de 1 a 20\n",
        "list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]\n",
        "for i in list:\n",
        "  valor = i % 2\n",
        "  if valor == 0:\n",
        "    print('Numero par:>', str(i))\n",
        "\n",
        " "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Numero par:> 2\n",
            "Numero par:> 4\n",
            "Numero par:> 6\n",
            "Numero par:> 8\n",
            "Numero par:> 10\n",
            "Numero par:> 12\n",
            "Numero par:> 14\n",
            "Numero par:> 16\n",
            "Numero par:> 18\n",
            "Numero par:> 20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dRKfvsQ_U0oC",
        "outputId": "a700aa4c-57e0-4c60-cb0a-7e5ca83551fd"
      },
      "source": [
        "#Inicio de aplicação\n",
        "for i in range(1,21):\n",
        "  if i % 2 ==0:\n",
        "    print(i)\n",
        "print('fim da aplicação')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n",
            "fim da aplicação\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x8bc0jUATU5E",
        "outputId": "75db9d8e-dbfd-439a-f4c5-c432c3e1cc30"
      },
      "source": [
        "#utilizando o conceito de FOR faça uma aplicação que mostre os numeros \n",
        "#pares na sequencia numerica de 1 a 20\n",
        "list = []\n",
        "inicio = 1\n",
        "fim = 11\n",
        "while inicio < fim:\n",
        "  entrada = int(input('Digite o ' + str(inicio) + 'º valor: '))\n",
        "  list.append(entrada)\n",
        "  inicio +=1\n",
        "print('lista feita>', list)\n",
        "for i in list:\n",
        "  valor = i % 2\n",
        "  if valor == 0:\n",
        "    print('Numero par:>', str(i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite o 1º valor: 10\n",
            "Digite o 2º valor: 5\n",
            "Digite o 3º valor: 6\n",
            "Digite o 4º valor: 8\n",
            "Digite o 5º valor: 9\n",
            "Digite o 6º valor: 11\n",
            "Digite o 7º valor: 45\n",
            "Digite o 8º valor: 5\n",
            "Digite o 9º valor: 9\n",
            "Digite o 10º valor: 100\n",
            "lista feita> [10, 5, 6, 8, 9, 11, 45, 5, 9, 100]\n",
            "Numero par:> 10\n",
            "Numero par:> 6\n",
            "Numero par:> 8\n",
            "Numero par:> 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k813pNPvV0_h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2256a3b1-51d3-451d-90c7-d898af97ce7a"
      },
      "source": [
        "#Utilizando o conceito de FOR faça uma aplicação que mostre a sequencia numerica \n",
        "#iniciando em 3 até 100 com invervalo de 5\n",
        "\n",
        "for i in range(3,100,5): #de 3 ate 100 de 5 em 5\n",
        "  print(i)"
      ],
      "execution_count": 152,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "8\n",
            "13\n",
            "18\n",
            "23\n",
            "28\n",
            "33\n",
            "38\n",
            "43\n",
            "48\n",
            "53\n",
            "58\n",
            "63\n",
            "68\n",
            "73\n",
            "78\n",
            "83\n",
            "88\n",
            "93\n",
            "98\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5kV3emN8XGjW",
        "outputId": "7145eeea-9919-4d8c-c5ca-bf6a56414d2e"
      },
      "source": [
        "#utlizando o conceito de FOR faça uma aplicação que mostre os nomes de uma lista\n",
        "lista = ['murilo', 'ronnan', 'maico', 'rodrigo', 'fernando', 'tiago']\n",
        "\n",
        "for i in lista:\n",
        "  print('Elemento: ', i, ' \\n Posição: ', lista.index(i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Elemento:  murilo  \n",
            " Posição:  0\n",
            "Elemento:  ronnan  \n",
            " Posição:  1\n",
            "Elemento:  maico  \n",
            " Posição:  2\n",
            "Elemento:  rodrigo  \n",
            " Posição:  3\n",
            "Elemento:  fernando  \n",
            " Posição:  4\n",
            "Elemento:  tiago  \n",
            " Posição:  5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ezcfb6qDXest",
        "outputId": "b0bf9d42-7844-4df3-b64f-4216b1d22b8d"
      },
      "source": [
        "#VERIFICAR AQUI PARA PROVA\n",
        "#Pergunte ao usuario se deseja digitar o nome\n",
        "#Se não deseja, finalize exibindo a lista e os itens\n",
        "#Se sim, incluir o nome na lista\n",
        "lista = []\n",
        "\n",
        "resposta = input('Deseja digitar um nome para lista: S/N')\n",
        "\n",
        "while resposta.upper() =='S':\n",
        "  entrada = input('Digite um nome para lista: ')\n",
        "  lista.append(entrada)\n",
        "  resposta = input('Deseja digitar outro um nome para lista: S/N')\n",
        "\n",
        "while resposta.upper() != 'S' and resposta.upper() != 'N':\n",
        "  print('Alternativa incorreta, S/N')\n",
        "  resposta = input('Deseja digitar um outro nome para lista: S/N')\n",
        "  while resposta.upper() =='S':\n",
        "    entrada = input('Digite um nome para lista: ')\n",
        "    lista.append(entrada)\n",
        "    resposta = input('Deseja digitar um outro nome para lista: S/N')    \n",
        "\n",
        "if resposta.upper() =='N':\n",
        "  print('Programa Finalizado')\n",
        "\n",
        "print(lista)\n",
        "for i in lista:\n",
        "  print(i)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Deseja digitar um nome para lista: S/Ns\n",
            "Digite um nome para lista: murilo\n",
            "Deseja digitar outro um nome para lista: S/Nn\n",
            "Programa Finalizado\n",
            "['murilo']\n",
            "murilo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "999J6_zkfIhA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a9c99d22-3f86-47af-fccf-4621a15082e0"
      },
      "source": [
        "#Escreva um programa que pergunte ao usuario quantos alunos ele tem em sua sala.\n",
        "#Em seguida, atraves de um laço FOR, peça ao usuario para que entre com as notas de \n",
        "#todos os alunos da sala, um por vez.\n",
        "#Por fim, o programa deve mostrar a media aritmetica da turma:\n",
        "\n",
        "quantidade = int(input('Digite quantidade total de alunos: '))\n",
        "inicio = 0\n",
        "elemento = inicio +1\n",
        "lista = []\n",
        "somatorio = 0\n",
        "\n",
        "while inicio < quantidade:\n",
        "  nota = input('digite a nota do ' + str(elemento) + 'º aluno: ')\n",
        "  lista.append(nota)\n",
        "  somatorio = somatorio + int(nota)\n",
        "  elemento +=1\n",
        "  inicio +=1\n",
        "\n",
        "print('Soma total das notas: ', somatorio)\n",
        "\n",
        "media = somatorio / quantidade\n",
        "\n",
        "print('Media total das notas: ', media)\n"
      ],
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite quantidade total de alunos: 3\n",
            "digite a nota do 1º aluno: 10\n",
            "digite a nota do 2º aluno: 2\n",
            "digite a nota do 3º aluno: 8\n",
            "Soma total das notas:  20\n",
            "Media total das notas:  6.666666666666667\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oKHmWYfrlPbq",
        "outputId": "638fd342-5303-46c5-964a-78ac43cdf1dd"
      },
      "source": [
        "#Escreva um programa que pergunte ao usuario quantos alunos ele tem em sua sala.\n",
        "#Em seguida, atraves de um laço FOR, peça ao usuario para que entre com as notas de \n",
        "#todos os alunos da sala, um por vez.\n",
        "#Por fim, o programa deve mostrar a media aritmetica da turma:\n",
        "\n",
        "quantidade = int(input('Digite quantidade total de alunos: '))\n",
        "somatorio = 0\n",
        "media = 0\n",
        "\n",
        "for aluno in range(quantidade):\n",
        "  melhoria = aluno +1\n",
        "  nota = (int(input('Insira a nota do'+ str(melhoria)+ ' º aluno: ')))\n",
        "  somatorio = somatorio + nota\n",
        "\n",
        "else: \n",
        "  media = somatorio / quantidade\n",
        "\n",
        "print('Media: ', media)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Digite quantidade total de alunos: 3\n",
            "Insira a nota do1 º aluno: 10\n",
            "Insira a nota do2 º aluno: 15\n",
            "Insira a nota do3 º aluno: 5\n",
            "Media:  10.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EIzB3DFdmjKV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df6bc89b-6c8a-4984-9a93-01ccadc36a49"
      },
      "source": [
        "#DESAFIO Feito Murilo - Aplicação para cadastro de doadores de sangue\n",
        "\n",
        "#Desenvolva uma aplicacao para o cadastro de doadores de sangue\n",
        "#Neste projeto a etapa que iremos solicitar o numero total de pessoas que serao cadastradas.\n",
        "#Considerar para a pessoa estar apta a doação de sangue é nao ter tipo resfriado nos ultimos 7 dias ao final devemos\n",
        "#apresentar a quantidade total de pessoas aptas a docação de sangue\n",
        "#apresentar a quantidadee de pessoas do sexo masculino aptas para doação e tambem do sexo feminino\n",
        "\n",
        "quantidade_cadastro = int(input('Quantas pessoas serão cadastrados ?: '))\n",
        "inicio = 0\n",
        "\n",
        "total_sexo_masculino = []\n",
        "total_sexo_feminino = []\n",
        "\n",
        "while inicio < quantidade_cadastro:\n",
        "  sexo = input('Digite o sexo M (masculino) ou F (feminino)')\n",
        "  if sexo.upper() != 'M' and sexo.upper() != 'F':\n",
        "    print('sexo invalido')\n",
        "    sexo = input('Digite o sexo M (masculino) ou F (feminino)')\n",
        "\n",
        "  resfriado = input('A pessoa esteve resfriado nos ultimos 7 dias ? S ou N ?')\n",
        "  if resfriado.upper() != 'S' and resfriado.upper() != 'N':\n",
        "    print('Opção invalida')\n",
        "    resfriado = input('A pessoa esteve resfriado nos ultimos 7 dias ? S ou N ?')\n",
        "\n",
        "  if resfriado.upper() == 'N' and sexo.upper() == 'M':\n",
        "    valor = 1\n",
        "    total_sexo_masculino.append(valor)\n",
        "  \n",
        "  elif resfriado.upper() == 'N' and sexo.upper() == 'F':\n",
        "    valor = 1\n",
        "    total_sexo_feminino.append(valor)\n",
        "\n",
        "  print('*** Proximo Registro ***')\n",
        "  inicio +=1\n",
        "\n",
        "total_masculino = 0\n",
        "\n",
        "for valor_m in total_sexo_masculino:\n",
        "  total_masculino +=valor_m\n",
        "\n",
        "print('A quantidade total do sexo masculino é: {}'.format(total_masculino))\n",
        "\n",
        "total_feminino = 0\n",
        "for valor_f in total_sexo_feminino:\n",
        "  total_feminino +=valor_f\n",
        "\n",
        "print('A quantidade total do sexo feminino é: {}'.format(total_feminino))\n",
        "\n",
        "print('Total de doadores aptos é: {}'.format((total_masculino+total_feminino)))"
      ],
      "execution_count": 154,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Quantas pessoas serão cadastrados ?: 2\n",
            "Digite o sexo M (masculino) ou F (feminino)m\n",
            "A pessoa esteve resfriado nos ultimos 7 dias ? S ou N ?n\n",
            "*** Proximo Registro ***\n",
            "Digite o sexo M (masculino) ou F (feminino)m\n",
            "A pessoa esteve resfriado nos ultimos 7 dias ? S ou N ?s\n",
            "*** Proximo Registro ***\n",
            "A quantidade total do sexo masculino é: 1\n",
            "A quantidade total do sexo feminino é: 0\n",
            "Total de doadores aptos é: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jxKsJ0JORGHE"
      },
      "source": [
        "#Feito Professor\n",
        "#Desenvolva uma aplicacao para o cadastro de doadores de sangue\n",
        "#Neste projeto a etapa que iremos solicitar o numero total de pessoas que serao cadastradas.\n",
        "#Considerar para a pessoa estar apta a doação de sangue é nao ter tipo resfriado nos ultimos 7 dias ao final devemos\n",
        "#apresentar a quantidade total de pessoas aptas a docação de sangue\n",
        "#apresentar a quantidadee de pessoas do sexo masculino aptas para doação e tambem do sexo feminino\n",
        "\n",
        "quantidade = int(input('Quantas pessoas serão cadastrados ?:'))\n",
        "totalM = 0\n",
        "totalF = 0\n",
        "\n",
        "for qtde in range(quantidade):\n",
        "  \n",
        "  sexo = input('Informe o sexo M/F: ')\n",
        "  while sexo.upper() != 'M' and sexo.upper() !='F':\n",
        "    print('Sexo invalido')\n",
        "    sexo = input('Informe o sexo M/F')\n",
        "\n",
        "  resfriado = input('Algum sintoma de resfriado nos ultimos 7 dias ? S/N: ')\n",
        "  while resfriado.upper() != 'S' and resfriado.upper() != 'N':\n",
        "    print('Opção invalida')\n",
        "    resfriado = input('Algum sintoma de resfriado nos ultimos 7 dias ? S/N: ')\n",
        "\n",
        "  if sexo.upper() == 'M' and resfriado.upper() == 'N':\n",
        "    totalM +=1\n",
        "  \n",
        "  elif sexo.upper() == 'F' and resfriado.upper() == 'N':\n",
        "    totalF +=1\n",
        "  \n",
        "  print('*** Proximo Registro ***')\n",
        "\n",
        "else:\n",
        "  print('Resultado final')\n",
        "\n",
        "print('Total de Mulheres aptas a doação = '+str(totalF))\n",
        "print('Total de Homens aptos a doação = '+str(totalM))\n",
        "print('Total Geral de doadores aptos = ' +str(totalF+totalM))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8tdjD00NmVp0"
      },
      "source": [
        "#Feito Murilo\n",
        "#Desenvolva uma aplicação que faça o cadastro de pessoas para um sistema de RH\n",
        "#O cadastro devera responder se sabe utilizar computador e seu nivel do idioma em ingles\n",
        "\n",
        "#Ao final devera apresentar quantidade de pessoas\n",
        "#que sabem utilizar o computador\n",
        "#que tem nivel basico de ingles\n",
        "#que tem nivel intermediario\n",
        "#que tem nivel avançado\n",
        "#que tem nivel avançado e sabem utilizar o computador\n",
        "\n",
        "print('*** PROGRAMA DE RH ***')\n",
        "\n",
        "entrada = input(print('Deseja cadastrar uma pessoa: S ou N'))\n",
        "contagem_computador = 0\n",
        "contagem_ingles_basico = 0\n",
        "contagem_ingles_intermediario = 0\n",
        "contagem_ingles_avancado = 0\n",
        "contagem_especial = 0 #que sabe utilizar o computador E tem nivel avançado\n",
        "\n",
        "#Opção invalida\n",
        "while entrada.upper() != 'S' and entrada.upper() != 'N':\n",
        "  print('opção invalida')\n",
        "  entrada = input(print('Deseja cadastrar uma pessoa: S ou N'))\n",
        "\n",
        "#Enquanto desejar cadastrar uma nova pessoa\n",
        "while entrada.upper() == 'S':\n",
        "  print('*** NOVO REGISTRO ***')\n",
        "  computador = input(print('A pessoa sabe utilizar um computador ? S ou N ?'))\n",
        "  while computador.upper() != 'S' and computador.upper() != 'N':\n",
        "    print('opção invalida')\n",
        "    computador = input(print('A pessoa sabe utilizar um computador ? S ou N ?'))\n",
        "\n",
        "  ingles = input(print('digite o nivel de ingles da pessoa \\n B - BASICO \\n I - INTERMEDIARIO \\n A - AVANÇADO'))\n",
        "  while ingles.upper() != 'B' and ingles.upper() != 'I' and ingles.upper() != 'A':\n",
        "    print('opção invalida')\n",
        "    ingles = input(print('digite o nivel de ingles da pessoa \\n B - BASICO \\n I - INTERMEDIARIO \\n A - AVANÇADO'))\n",
        "\n",
        "  if computador.upper() == 'S' and ingles.upper() == 'B':\n",
        "    contagem_computador +=1  \n",
        "    contagem_ingles_basico +=1\n",
        "     \n",
        "  elif computador.upper() == 'S' and ingles.upper() == 'I':\n",
        "    contagem_computador +=1  \n",
        "    contagem_ingles_intermediario +=1\n",
        "     \n",
        "  elif computador.upper() == 'S' and ingles.upper() == 'A':\n",
        "    contagem_computador +=1  \n",
        "    contagem_ingles_avancado +=1\n",
        "    contagem_especial +=1\n",
        "      \n",
        "  elif computador.upper() == 'N' and ingles.upper() == 'B':\n",
        "    contagem_ingles_basico +=1\n",
        "     \n",
        "  elif computador.upper() == 'N' and ingles.upper() == 'I':\n",
        "    contagem_ingles_intermediario +=1\n",
        "      \n",
        "  elif computador.upper() == 'N' and ingles.upper() == 'A':\n",
        "    contagem_ingles_avancado +=1\n",
        "    \n",
        "  entrada = input(print('Deseja cadastrar uma pessoa: S ou N'))\n",
        "      \n",
        "print('Quantidade de pessoas que sabe utlizar o computador é de: {}'.format(contagem_computador))\n",
        "print('Quantidade de pessoas com ingles basico é: {} intermediario é: {} avançado é: {}'.format(contagem_ingles_basico,contagem_ingles_intermediario,contagem_ingles_avancado))\n",
        "print('Quantidade que tem nivel avançado e sabem usar o computador é: {}'.format(contagem_especial))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q-Xfr-cU5nSk",
        "outputId": "733760ea-e40c-4f3a-9b5b-422bf8d0e675"
      },
      "source": [
        "#Feito Professor:\n",
        "usocomputador = 0\n",
        "basico = 0\n",
        "intermediario = 0\n",
        "avancado = 0\n",
        "compIdioma = 0\n",
        "\n",
        "cadastro = input('Deseja efetuar o cadastro ? [S] [N]')\n",
        "\n",
        "while cadastro.upper() != 'S' and cadastro.upper() != 'N':\n",
        "  print('responda S ou N')\n",
        "  cadastro = input('Deseja efetuar o cadastro ? [S] [N]')\n",
        "\n",
        "while cadastro.upper() == 'S':\n",
        "  print('**********')\n",
        "  print('Iniciar Cadastro')\n",
        "  print('**********')\n",
        "  comp = input('sabe utilizar o computador ? S ou N')\n",
        "  while comp.upper() != 'S' and comp.upper() != 'N':\n",
        "    print('opçao invalida')\n",
        "    comp = input('sabe utilizar o computador ? S ou N')\n",
        "\n",
        "  ingles = input('nivel do idioma: B (Basico) | I (Intermediario) | A (Avançado)')\n",
        "  while ingles.upper() != 'B' and ingles.upper() != 'I' and ingles.upper() != 'A':\n",
        "    print('resposta B (Basico) | I (Intermediario) | A (Avançado)')\n",
        "    ingles = input('nivel do idioma: B (Basico) | I (Intermediario) | A (Avançado)')\n",
        "  \n",
        "  if comp.upper() == 'S':\n",
        "    usocomputador +=1\n",
        "  \n",
        "  if ingles.upper() == 'B':\n",
        "    basico +=1\n",
        "  elif ingles.upper() == 'I':\n",
        "    intermediario +=1\n",
        "  else:\n",
        "    avancado +=1\n",
        "\n",
        "  if comp.upper() == 'S' and ingles.upper() == 'A':\n",
        "    compIdioma +=1\n",
        "\n",
        "  cadastro = input('Deseja efetuar o cadastro ? [S] [N]')\n",
        "  while cadastro.upper() != 'S' and cadastro.upper() != 'N':\n",
        "    print('responda S ou N')\n",
        "\n",
        "else: \n",
        "  print('*****FIM DOS CADASTROS*****')\n",
        "\n",
        "print('Total das pessoas que sabem utilizar o computador: {}'.format(usocomputador))\n",
        "print('Total das pessoas com nivel basico de ingles: {}'.format(basico))\n",
        "print('Total das pessoas com nivel basico de intermediario: {}'.format(intermediario))\n",
        "print('Total das pessoas com nivel basico de avançado: {}'.format(avancado))\n",
        "print('Total de quem sabe utilizar o computador e tem nivel avançado de ingles: {}'.format(compIdioma))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Deseja efetuar o cadastro ? [S] [N]s\n",
            "**********\n",
            "Iniciar Cadastro\n",
            "**********\n",
            "sabe utilizar o computador ? S ou Ns\n",
            "nivel do idioma: B (Basico) | I (Intermediario) | A (Avançado)a\n",
            "Deseja efetuar o cadastro ? [S] [N]s\n",
            "**********\n",
            "Iniciar Cadastro\n",
            "**********\n",
            "sabe utilizar o computador ? S ou Ns\n",
            "nivel do idioma: B (Basico) | I (Intermediario) | A (Avançado)b\n",
            "Deseja efetuar o cadastro ? [S] [N]n\n",
            "*****FIM DOS CADASTROS*****\n",
            "Total das pessoas que sabem utilizar o computador: 2\n",
            "Total das pessoas com nivel basico de ingles: 1\n",
            "Total das pessoas com nivel basico de intermediario: 0\n",
            "Total das pessoas com nivel basico de avançado: 1\n",
            "Total de quem sabe utilizar o computador e tem nivel avançado de ingles: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8jkVVM1BSa4L",
        "outputId": "494148bd-34cc-4223-d6da-134e32b6385f"
      },
      "source": [
        "#Desafio completo notas, medias e aprovação alunos\n",
        "#Professor\n",
        "\n",
        "#Desenvolva uma aplicação que repita a inserção de dados\n",
        "#de alunos (nome, nota1, nota2 e nota3) até que o usuario\n",
        "#peça para parar a aplicação.\n",
        "#As notas para setem consideradas validas devem estar entre 0 e 10\n",
        "#Apresente ao final:\n",
        "#Atde de alunos aprovados (media >=7)\n",
        "#Qtde de alunos reprovados (media<4)\n",
        "#Qtde de alunos de exame final (meida >=4 e media <7)\n",
        "\n",
        "aprovados = 0\n",
        "exame = 0\n",
        "reprovados = 0\n",
        "\n",
        "cadastrar = input('Dseseja iniciar lançamentos ? [S] [N]')\n",
        "\n",
        "while cadastrar.upper() != 'S' and cadastrar.upper() != 'N':\n",
        "  print('Opção invalida, insira [S] ou [N')\n",
        "  cadastrar = input('Dseseja iniciar lançamentos ? [S] [N]')\n",
        "\n",
        "while cadastrar.upper() == 'S':\n",
        "  nome = input('Informe o nome do aluno: ')\n",
        "  for cont in range(0,3):\n",
        "    if cont ==0:\n",
        "      nota1 = int(input('Informe a N1: '))\n",
        "      while nota1<0 or nota1>10:\n",
        "        print('Opção invalida, N1 deve ser entre 0 e 10')\n",
        "        nota1 = int(input('Informe a N1: '))\n",
        "    elif cont ==1:\n",
        "      nota2 = int(input('Informe a N2: '))\n",
        "      while nota2<0 or nota2>10:\n",
        "        print('Opção invalida, N2 deve ser entre 0 e 10')\n",
        "        nota2 = int(input('Informe a N2: '))\n",
        "    else:\n",
        "      nota3 = int(input('Informe a N3: '))\n",
        "      while nota3<0 or nota3>10:\n",
        "        print('Opção invalida, N3 deve ser entre 0 e 10')\n",
        "        nota3 = int(input('Informe a N3: '))\n",
        "\n",
        "  #calcular media e verfificar status aprovado, reprovado ou exame\n",
        "  media = ((nota1+nota2+nota3)/3)\n",
        "  print('A media do {} é: {}'.format(nome,media))\n",
        "  if media >=7:\n",
        "    aprovados +=1\n",
        "  elif media <4:\n",
        "    reprovados +=1\n",
        "  else:\n",
        "    exame +=1\n",
        "  cadastrar = input('Dseseja efeturar outro lançamento ? [S] [N]')\n",
        "  while cadastrar.upper() != 'S' and cadastrar.upper() != 'N':\n",
        "    print('Opção invalida, insira [S] ou [N')\n",
        "    cadastrar = input('Dseseja efeturar outro lançament ? [S] [N]')\n",
        "\n",
        "else:\n",
        "  print('***** Lançamentos Finalizados *****')\n",
        "\n",
        "\n",
        "print('Total de alunos Aprovados é de: {}'.format(aprovados))\n",
        "print('Total de alunos Exames é de: {}'.format(reprovados))\n",
        "print('Total de alunos Reprovados é de: {}'.format(exame))"
      ],
      "execution_count": 155,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dseseja iniciar lançamentos ? [S] [N]s\n",
            "Informe o nome do aluno: murilo\n",
            "Informe a N1: 10\n",
            "Informe a N2: 2\n",
            "Informe a N3: 8\n",
            "A media do murilo é: 6.666666666666667\n",
            "Dseseja efeturar outro lançamento ? [S] [N]s\n",
            "Informe o nome do aluno: maico\n",
            "Informe a N1: 5\n",
            "Informe a N2: 10\n",
            "Informe a N3: 45\n",
            "Opção invalida, N3 deve ser entre 0 e 10\n",
            "Informe a N3: 5\n",
            "A media do maico é: 6.666666666666667\n",
            "Dseseja efeturar outro lançamento ? [S] [N]s\n",
            "Informe o nome do aluno: ronnan\n",
            "Informe a N1: 2\n",
            "Informe a N2: 2\n",
            "Informe a N3: 2\n",
            "A media do ronnan é: 2.0\n",
            "Dseseja efeturar outro lançamento ? [S] [N]n\n",
            "***** Lançamentos Finalizados *****\n",
            "Total de alunos Aprovados é de: 0\n",
            "Total de alunos Exames é de: 1\n",
            "Total de alunos Reprovados é de: 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pvgiXH02ru7K"
      },
      "source": [
        "**FUNÇÕES**\n",
        "Seria melhor para o codigo se a função execute apenas uma ação"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0nVq9riGrxmw",
        "outputId": "5dbb7fa0-fc3e-47e4-d49c-477926b8800b"
      },
      "source": [
        "#Murilo\n",
        "#Faça um algoritmo que solicite ao usuario numeros e armazene em um vetor de 10 posições\n",
        "#Crie uma função que recebe o vetor preenchido e substitua \n",
        "#todas as ocorrencias de valores positivos por 1 e valores negativos por 0\n",
        "\n",
        "numeros = []\n",
        "\n",
        "for i in range(0,10):\n",
        "  valor = int(input('Digite {}º numero: '.format(i+1)))\n",
        "  numeros.append(valor)\n",
        "\n",
        "print('Primeira parte: {}'.format(numeros))\n",
        "\n",
        "inicio = 0\n",
        "final = 10\n",
        "\n",
        "while inicio < final:\n",
        "  if numeros[inicio] >= 0:\n",
        "    numeros[inicio] = 1\n",
        "  else:\n",
        "    numeros[inicio] = 0\n",
        "  inicio +=1\n",
        "\n",
        "print('Segunda parte: {}'.format(numeros))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite 1º numero: -9\n",
            "Digite 2º numero: 5\n",
            "Digite 3º numero: 4\n",
            "Digite 4º numero: 2\n",
            "Digite 5º numero: -11\n",
            "Digite 6º numero: 45\n",
            "Digite 7º numero: 6\n",
            "Digite 8º numero: -8\n",
            "Digite 9º numero: 0\n",
            "Digite 10º numero: 1\n",
            "Primeira parte: [-9, 5, 4, 2, -11, 45, 6, -8, 0, 1]\n",
            "Segunda parte: [0, 1, 1, 1, 0, 1, 1, 0, 1, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gs7fwFH321QN",
        "outputId": "ff01db06-ab1c-488b-9935-2e9508dba074"
      },
      "source": [
        "#Professor \n",
        "\n",
        "#construindo o vetor\n",
        "original=[0]*10\n",
        "\n",
        "for i in range(10):\n",
        "  original[i] = int(input('Digite o {}º um valor: '.format(i+1)))\n",
        "\n",
        "saida_original = original\n",
        "print('Lista original é: {}'.format(saida_original))\n",
        "\n",
        "def troca(lista_alterada):\n",
        "  for i in range(10):\n",
        "    if lista_alterada[i]>=0:\n",
        "      lista_alterada[i] = 1\n",
        "    else: \n",
        "      lista_alterada[i] = 0\n",
        "  print('Alterados é: {}'.format(lista_alterada))\n",
        "  \n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "\n",
        "  troca(original)\n",
        "  \n",
        "  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite o 1º um valor: 5\n",
            "Digite o 2º um valor: -1\n",
            "Digite o 3º um valor: -99\n",
            "Digite o 4º um valor: 5\n",
            "Digite o 5º um valor: 0\n",
            "Digite o 6º um valor: 0\n",
            "Digite o 7º um valor: 1\n",
            "Digite o 8º um valor: -2\n",
            "Digite o 9º um valor: -2\n",
            "Digite o 10º um valor: -4\n",
            "Lista original é [5, -1, -99, 5, 0, 0, 1, -2, -2, -4]\n",
            "Alterados [1, 0, 0, 1, 1, 1, 1, 0, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-lND284pBlYE"
      },
      "source": [
        "**Recursividade é você ter uma função chamando ela propria**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TUROK7k1BaSb",
        "outputId": "ce66703f-58ef-4c74-ccad-43f105f4e9c9"
      },
      "source": [
        "#Calcular fatorial\n",
        "def calcular_fatorial(numero):\n",
        "  if numero == 0 or numero == 1:\n",
        "    return 1\n",
        "  else:\n",
        "    return numero * fatorial(numero-1)\n",
        "\n",
        "if __name__ == '__main__':\n",
        "\n",
        "   valor = int(input('Informe um numero: '))\n",
        "\n",
        "   resposta = calcular_fatorial(valor)\n",
        "\n",
        "   print('O fatorial de {} é: {}'.format(valor,resposta))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Informe um numero: 5\n",
            "O fatorial de 5 é: 120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zwBNjmMrOjaG",
        "outputId": "8e91c683-fa83-4c70-c0c3-8b914b7ce6ef"
      },
      "source": [
        "#criar função de fibonnaci\n",
        "\n",
        "def fibonacci(numero):\n",
        "  if numero <= 1:\n",
        "    return numero\n",
        "  \n",
        "  else:\n",
        "    return fibonacci(numero-1) + fibonacci(numero-2)\n",
        "\n",
        "if __name__ == '__main__':\n",
        "\n",
        "  posicao = int(input('Informe posição do Fibonacci: '))\n",
        "\n",
        "  resultado = fibonacci(posicao)\n",
        "\n",
        "  print('O fibonacci da posição {} é: {}'.format(posicao,resultado))\n",
        "\n",
        "# 1 1 2 3 5 8 13 21 46"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Informe posição do Fibonacci: 7\n",
            "O fibonacci da posição 7 é: 13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dLMBxbMwRT-x",
        "outputId": "32975805-41ce-4bc1-db8d-b871af084a97"
      },
      "source": [
        "#Murilo\n",
        "#Solicite quantas posição de fibo a pessoa deseja\n",
        "#imprima na tela fibonnaci # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597\n",
        "\n",
        "quantidade = int(input('Quantas posições de fibonacci deseja: '))\n",
        "\n",
        "valor = 1\n",
        "resultado = [0, 1, 1]\n",
        "resposta = 1\n",
        "\n",
        "if quantidade == 1: \n",
        "  resultado = [0,1]\n",
        "  print('posições de fibonacci é: {}'.format(resultado))\n",
        "\n",
        "elif quantidade ==2:\n",
        "  resultado = [0,1,1]\n",
        "  print('posições de fibonacci é: {}'.format(resultado))\n",
        "\n",
        "elif quantidade >2:\n",
        "\n",
        "  inicio = 3\n",
        "  posicao_inicial_soma = 1\n",
        "  posicao_final_soma = 2\n",
        "  while inicio < quantidade:\n",
        "  \n",
        "    resultado.append(resultado[posicao_inicial_soma] + resultado[posicao_final_soma])\n",
        "    inicio +=1\n",
        "    posicao_inicial_soma +=1\n",
        "    posicao_final_soma +=1\n",
        "\n",
        "  print(resultado)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Quantas posições de fibonacci deseja: 80\n",
            "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 1548008755920, 2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853, 72723460248141, 117669030460994, 190392490709135, 308061521170129, 498454011879264, 806515533049393, 1304969544928657, 2111485077978050, 3416454622906707, 5527939700884757, 8944394323791464, 14472334024676221]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-AjkN2NlgiXr",
        "outputId": "7f28cf8b-544d-49f0-e23a-6e0d65574db0"
      },
      "source": [
        "#Murilo\n",
        "#Fazer uma função que ira retornar os resultados de operações entre dois numeros:\n",
        "#retornar se o primeiro numero é par\n",
        "#retornar a multiplicação do primeiro com o segundo\n",
        "\n",
        "def validacao(numero,numero2):\n",
        "  if numero % 2 == 0:\n",
        "    print('O {} É PAR'.format(numero))\n",
        "    resultado = numero*numero2\n",
        "    print('Multiplicação de {} * {} é: {}'.format(numero, numero2, resultado))\n",
        "  \n",
        "  else:\n",
        "    print('O {} É IMPAR'.format(numero))\n",
        "    resultado = numero*numero2\n",
        "    print('Multiplicação de {} * {} é: {}'.format(numero, numero2, resultado))\n",
        "\n",
        "if __name__ == '__main__':\n",
        "\n",
        "    numero = int(input('Digite o primeiro numero qualquer: '))\n",
        "    numero2= int(input('Digite o segundo numero qualquer: '))\n",
        "\n",
        "    validacao(numero,numero2)\n",
        "    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite o primeiro numero qualquer: 8\n",
            "Digite o segundo numero qualquer: 2\n",
            "O 8 É PAR\n",
            "Multiplicação de 8 * 2 é: 16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "unxK-HUxkS-m",
        "outputId": "6c1f0578-6b07-4703-e22e-07ee5bce79be"
      },
      "source": [
        "#Professor\n",
        "#Fazer uma função que ira retornar os resultados de operações entre dois numeros:\n",
        "#retornar se o primeiro numero é par\n",
        "#retornar a multiplicação do primeiro com o segundo\n",
        "\n",
        "def calcular(x,y):\n",
        "  return x%2 == 0, x*y\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  num = int(input('Digite o primeiro numero: '))\n",
        "  num2 = int(input('Digite o segundo numero: '))\n",
        "  resultado = calcular(num,num2)\n",
        "  print(resultado)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite o primeiro numero: 2\n",
            "Digite o segundo numero: 2\n",
            "(True, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fyRs512Yn4KX",
        "outputId": "04ee24eb-469a-4746-e818-6f039083df44"
      },
      "source": [
        "#Murilo\n",
        "#Fazer uma função que calcule a area de um circuto\n",
        "import math\n",
        "pi = math.pi\n",
        "\n",
        "def calculo_area(raio):\n",
        "  return ((raio**2) * pi)\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  raio = float(input('Digite o valor do raio em metros: '))\n",
        "  \n",
        "  resultado = calculo_area(raio)\n",
        "   \n",
        "  print('Raio informado: {} sendo assim sua Área é: {:.2f}'.format(raio,resultado))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite o valor do raio em metros: 2\n",
            "Raio informado: 2.0 sendo assim sua Área é: 12.57\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-m9z3cte4ZWm"
      },
      "source": [
        "**Trabalhando com Random**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4OwzvXZE4JnJ",
        "outputId": "9cc99897-20b6-405f-d174-4fe38a0839b2"
      },
      "source": [
        "import random \n",
        "\n",
        "numero = random.randint(0,100) #aletorio de 0 a 100\n",
        "\n",
        "print(numero)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tgIcwe0H5A2f",
        "outputId": "14f79eb4-cf32-411e-cb66-7385ffa5e887"
      },
      "source": [
        "#Murilo\n",
        "#Crie uma lista de 10 posições com numeros randomicos\n",
        "#limitados a 100\n",
        "\n",
        "import random\n",
        "inicio = 0\n",
        "final = 10\n",
        "lista = []\n",
        "\n",
        "while inicio < final:\n",
        "  valor = random.randrange(100)\n",
        "  lista.append(valor)\n",
        "  inicio +=1\n",
        "\n",
        "print('Lista Gerada Automaticamente: {}'.format(lista))\n",
        "\n",
        "palavras_ordenadas = sorted(lista)\n",
        "print('Lista Gerada Automaticamente Ordenadamente: {}'.format(palavras_ordenadas))\n",
        "\n",
        "quantidade = len(lista)\n",
        "print('Quantidade de itens na lista: {}'.format(quantidade))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Lista Gerada Automaticamente: [5, 42, 36, 86, 18, 33, 50, 32, 9, 90]\n",
            "Lista Gerada Automaticamente Ordenadamente: [5, 9, 18, 32, 33, 36, 42, 50, 86, 90]\n",
            "Quantidade de itens na lista: 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LZUUTpb9-PuB",
        "outputId": "eab26aa0-4005-4927-d7de-7e2ea13e53dc"
      },
      "source": [
        "#Murilo\n",
        "#Crie uma lista de 20 posições com numeros randomicos\n",
        "#variando entre 1000 e 2000\n",
        "\n",
        "import random\n",
        "lista = []\n",
        "for x in range(20):\n",
        "  lista.append(random.randint(1000,2000))\n",
        "\n",
        "print('Lista Gerada Automaticamente: {}'.format(lista))\n",
        "\n",
        "palavras_ordenadas = sorted(lista)\n",
        "print('Lista Gerada Automaticamente Ordenadamente: {}'.format(palavras_ordenadas))\n",
        "\n",
        "quantidade = len(lista)\n",
        "print('Quantidade de itens na lista: {}'.format(quantidade))\n",
        "\n",
        "#sorteando 2 valores dos valores da lista\n",
        "sorteio = random.sample(lista, 2) #Sorteando 2 numeros da lista\n",
        "print('Valores sorteados foram: {}'.format(sorteio))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Lista Gerada Automaticamente: [1459, 1103, 1640, 1256, 1390, 1330, 1978, 1041, 1947, 1086, 1299, 1473, 1489, 1674, 1205, 1029, 1446, 1524, 1677, 1664]\n",
            "Lista Gerada Automaticamente Ordenadamente: [1029, 1041, 1086, 1103, 1205, 1256, 1299, 1330, 1390, 1446, 1459, 1473, 1489, 1524, 1640, 1664, 1674, 1677, 1947, 1978]\n",
            "Quantidade de itens na lista: 20\n",
            "Valores sorteados foram: [1947, 1640]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MJpBWSqPAoDs"
      },
      "source": [
        "**Utilizando Type**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g6bpn2hhArxW",
        "outputId": "7a2f18b7-8e9d-4fbe-9626-a704a7a498cf"
      },
      "source": [
        "print(type('IFPS - Sertãozinho'))\n",
        "print(type(1010))\n",
        "print(type(9.25))\n",
        "print(type(True))\n",
        "\n",
        "c = ['a', 1, 'b', 2, True]\n",
        "\n",
        "print(type(c))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'bool'>\n",
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MfFUWk9LZyyH"
      },
      "source": [
        "**Utilizando funções anonimas lambda**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3s5W6zKMZ1px",
        "outputId": "0c706bdb-db02-4ffa-90e7-9cf0ae43a8d2"
      },
      "source": [
        "#Função DEF\n",
        "def subtracao1(num1,num2):\n",
        "  resultado1 = num1 - num2\n",
        "  print('\\n')\n",
        "  print('RESULTADO COM DEF')\n",
        "  print('Subtração entre {} - {} = {}'.format(num1, num2,resultado1))\n",
        "\n",
        "#LAMBDA\n",
        "subtracao2 = lambda num1,num2: num1-num2\n",
        "\n",
        "if __name__ == '__main__':\n",
        "\n",
        "  num1 = int(input('Digite o primeiro numero: '))\n",
        "  num2 = int(input('Digite o segundo numero: '))  \n",
        "\n",
        "#utilizando função def\n",
        "  subtracao1(num1,num2)\n",
        "\n",
        "#utilizando lambda\n",
        "  resultado2 = subtracao2(num1,num2)\n",
        "  print('\\n')\n",
        "  print('RESULTADO COM LAMBDA')\n",
        "  print('Subtração entre {} - {} = {}'.format(num1, num2,resultado2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite o primeiro numero: 52\n",
            "Digite o segundo numero: 25\n",
            "\n",
            "\n",
            "RESULTADO COM DEF\n",
            "Subtração entre 52 - 25 = 27\n",
            "\n",
            "\n",
            "RESULTADO COM LAMBDA\n",
            "Subtração entre 52 - 25 = 27\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bx4CTlSpju62",
        "outputId": "4f3b125f-867e-478f-834c-3e19f85b96d2"
      },
      "source": [
        "#Exercicio\n",
        "#Faça uma expressão para efetuar a soma de 2 numeros\n",
        "\n",
        "somar = lambda num1,num2: num1+num2\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  num1 = int(input('Digite um numero: '))\n",
        "  num2 = int(input('Digite outro numero: '))\n",
        "\n",
        "  print('Resultado de {} + {} = {}'.format(num1,num2,(somar(num1,num2))))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite um numero: 2\n",
            "Digite outro numero: 2\n",
            "Resultado de 2 + 2 = 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "38zMisDnoNGf",
        "outputId": "d5e9d9a5-ae4b-4fb9-e033-140c7b6e1b5f"
      },
      "source": [
        "#Exercicio - Professor\n",
        "\n",
        "#iremos percorrer os valores de uma lista e elevados ao quadrado\n",
        "#Assim é retornado o dobro deles com a operação x²\n",
        "#e com a operação ira retornar um map object #utilizamos \n",
        "#o metodo list para voltar a ter um array\n",
        "\n",
        "lista = [1,2,3,4,5]\n",
        "\n",
        "elevado = list(map(lambda x: x**2, lista))\n",
        "\n",
        "print(elevado)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "prRg_6rtpI8T",
        "outputId": "285e66bc-67bd-4221-d93c-7fbed9b9d974"
      },
      "source": [
        "#Outra maneira Murilo\n",
        "lista = [1,2,3,4,5]\n",
        "resultado = []\n",
        "for i in lista:\n",
        " elev = lambda x: i ** 2\n",
        " resultado.append(elev(i)) \n",
        "\n",
        "print(resultado)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xPLyzipPrYVb",
        "outputId": "cddb0554-889e-43fe-9dfe-878117f43a60"
      },
      "source": [
        "#Outra maneira Murilo\n",
        "lista = [1,2,3,4,5]\n",
        "resultado_2 = []\n",
        "for valor in lista:\n",
        "  novo_valor = valor ** 2\n",
        "  resultado_2.append(novo_valor)\n",
        "\n",
        "print(resultado_2)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kdYUmk60sZL2",
        "outputId": "67991624-047c-4ce4-9772-153d62baade0"
      },
      "source": [
        "#Professor\n",
        "items = [1,2,3,4,5]\n",
        "dobro = list(map(lambda x: x*2, items))\n",
        "print(dobro)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L-BQYzOclaR5",
        "outputId": "55c79ffd-0149-4e22-fdf2-b78f9708645d"
      },
      "source": [
        "curso = 'testandoessafrase'\n",
        "\n",
        "print(curso.isalnum()) #todo tipo de numero com letra\n",
        "print(curso.isalpha()) #somente letra (não pode conter espaços, numeros ou caracteres especiais)\n",
        "print(curso.isnumeric()) #somente numero\n",
        "print(curso.title())"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "True\n",
            "False\n",
            "Testandoessafrase\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RAiYfqfsmUi5",
        "outputId": "ead345b0-be1c-40ca-9ad0-c83f2bb12e7f"
      },
      "source": [
        "msg = 'Python'\n",
        "\n",
        "print('_/_'.join(msg))"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "P_/_y_/_t_/_h_/_o_/_n\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zrlReGHSmnFa",
        "outputId": "46167dd5-c734-40d7-b5ae-d68bdc1f93ca"
      },
      "source": [
        "frase = 'banana e maçã mas eu , eu prefiro a maçã'\n",
        "\n",
        "#criando uma lista\n",
        "lista = frase.split(' ')\n",
        "print(lista)\n",
        "\n",
        "#removendo duplicado\n",
        "lista_unica = list(set(lista))\n",
        "\n",
        "#imprimindo contagem para 2 repetidos\n",
        "for valor in lista_unica:\n",
        "  if valor in lista:\n",
        "    contagem = lista.count(valor)\n",
        "    if contagem == 2:\n",
        "      print('{}: qtde {}'.format(valor, contagem))\n",
        "\n",
        "#imprimindo contagem para 1 repetido\n",
        "for valor in lista_unica:\n",
        "  if valor in lista:\n",
        "    contagem = lista.count(valor)\n",
        "    if contagem == 1:\n",
        "      print('{}: qtde {}'.format(valor, contagem))\n",
        "\n",
        "    "
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['banana', 'e', 'maçã', 'mas', 'eu', ',', 'eu', 'prefiro', 'a', 'maçã']\n",
            "eu: qtde 2\n",
            "maçã: qtde 2\n",
            "mas: qtde 1\n",
            "banana: qtde 1\n",
            "a: qtde 1\n",
            "prefiro: qtde 1\n",
            "e: qtde 1\n",
            ",: qtde 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FKkMO6M32aGa",
        "outputId": "8c988c69-1a9d-4255-c9ec-2a1d572f5ae4"
      },
      "source": [
        "frase = 'separando letra por letra'\n",
        "\n",
        "frase_sem_espaço = frase.replace(' ', '')\n",
        "print(frase_sem_espaço)\n",
        "\n",
        "lista_final = []\n",
        "\n",
        "for letra in frase_sem_espaço:\n",
        "  letra.split(letra)\n",
        "  lista_final.append(letra)\n",
        "  \n",
        "print(lista_final)"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "separandoletraporletra\n",
            "['s', 'e', 'p', 'a', 'r', 'a', 'n', 'd', 'o', 'l', 'e', 't', 'r', 'a', 'p', 'o', 'r', 'l', 'e', 't', 'r', 'a']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i2fTQnwD4Eou",
        "outputId": "982b92a3-410d-4950-ce3d-368d3b09f3a6"
      },
      "source": [
        "frutas = 'maçã#bana#laranja#'\n",
        "resultado = frutas.split('#',2) #Com split além de especificar o separador você pode também controlar o número de divisões que irão ocorrer.\n",
        "print(resultado)"
      ],
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['maçã', 'bana', 'laranja#']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pkh_C0LP5OhD",
        "outputId": "3b5a1c5b-40a7-4878-9b04-3fdaf1186b1b"
      },
      "source": [
        "#Metodo partition\n",
        "'''\n",
        "O método partition() procura uma string especificada e divide a string em uma tupla contendo três elementos.\n",
        "\n",
        "  O primeiro elemento contém a parte antes da sequência especificada.\n",
        "  O segundo elemento contém a sequência especificada.\n",
        "  O terceiro elemento contém a parte após a sequência.\n",
        "'''\n",
        "\n",
        "msg = 'Estudar diariamente para melhorar'\n",
        "\n",
        "result = msg.partition('paraa')\n",
        "\n",
        "print(result)"
      ],
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Estudar diariamente para melhorar', '', '')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jjh9rVHhF8NQ",
        "outputId": "91dd62af-60ec-45db-f65e-dee2efc4b30a"
      },
      "source": [
        "msg = 'Curso de Python'\n",
        "\n",
        "print(msg.split())"
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Curso', 'de', 'Python']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iDHEAuqPJiE_",
        "outputId": "de36d404-7781-4f65-f3c0-a8c0bd92fc9c"
      },
      "source": [
        "#Buscando algo informando a posição inicial e a posição final\n",
        "\n",
        "frase = 'Murilo está testando uma frase'\n",
        "inicio = int(input('Digite posição inicial: '))\n",
        "final = int(input('Digite posição final: '))\n",
        "busca = 'M'\n",
        "              #oque estou buscando, posição inicial, posição final\n",
        "print(frase.find(busca,inicio,final))"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite posição inicial: 1\n",
            "Digite posição final: 10\n",
            "-1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1iZZcF8YhYn6",
        "outputId": "708629be-1a62-463f-f2ec-f0135c5c8a72"
      },
      "source": [
        "msg = 'testando formatação {} e {}'\n",
        "\n",
        "print(msg.format('teste A', 'teste B'))"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testando formatação teste A e teste B\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wKn-QYQGh5VC",
        "outputId": "9ae4adef-7c34-42f2-c4ed-df315794d9dd"
      },
      "source": [
        "#formatando centro\n",
        "var = ' Formatação de strings '\n",
        "valor = var.center(50,'#') #total de 50 caracteres\n",
        "print(valor)"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "############# Formatação de strings ##############\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sOSDVGKUidsZ",
        "outputId": "0949ebe4-3ffa-4e24-a1e6-c360401862d3"
      },
      "source": [
        "#formatando a esquerda\n",
        "var = ' Formatação a esquerda '\n",
        "valor = var.ljust(50,'<')\n",
        "print(valor)"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " Formatação a esquerda <<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZzRYU5IvioO-",
        "outputId": "2fbec2d4-6206-41e1-f578-cce5352dd4f4"
      },
      "source": [
        "#formatação a direita\n",
        "var = ' Formatação a direita '\n",
        "valor = var.rjust(50, '>')\n",
        "print(valor)"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            ">>>>>>>>>>>>>>>>>>>>>>>>>>>> Formatação a direita \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hqRQkba-jJod",
        "outputId": "8bb4ad03-8e24-4d3c-bfda-68c9c8150db3"
      },
      "source": [
        "#formatação de string\n",
        "\n",
        "texto = '{} este tipo de formatação no {outro}'.format('testando', outro='Python')\n",
        "\n",
        "print(texto.upper())"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "TESTANDO ESTE TIPO DE FORMATAÇÃO NO PYTHON\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gznMYxqKklNy",
        "outputId": "075854fb-6744-41e1-f52f-42bc8af2fc9c"
      },
      "source": [
        "#Percentual\n",
        "\n",
        "print('O percentual %d de alunos aprovado foi %1.3f' %(237,109.438725))"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O percentual 237 de alunos aprovado foi 109.439\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EDxhkAILmJ0r",
        "outputId": "0e030297-7a21-424c-fcc1-8647381018de"
      },
      "source": [
        "#trabalhando com string\n",
        "\n",
        "print('o nº de {string} foi {t:2d}'.format(string='alunos'.upper(), t=54))"
      ],
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "o nº de ALUNOS foi 54\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PhJIiYiAm2Jf",
        "outputId": "bfa0f37c-ab69-4211-98fe-48ad4812a1d2"
      },
      "source": [
        "print('Curso {} com \"{}\"'.format('Python', 'IFSP'))"
      ],
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Curso Python com \"IFSP\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2SHZPKuAnOho",
        "outputId": "20c6b394-7da1-496c-ddb3-38e84a11315c"
      },
      "source": [
        "print('Total de Cursos: %2d, Total Alunos: %4d' %(25,1427))"
      ],
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total de Cursos: 25, Total Alunos: 1427\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oiZ2J8r4oL1M",
        "outputId": "3c19b1ee-56af-4c26-e904-6e8114dae35d"
      },
      "source": [
        "#Programa de doação de cabelos\n",
        "#Condições\n",
        "  #mecha deve ser maior do que 10 cm\n",
        "  #durante o processo de doação os cabelos não podem ter tocados no chão\n",
        "  #doador nao pode possuir doença capilar\n",
        "  #todos os fios devem ser armazenados\n",
        "\n",
        "continuar = str(input('Deseja iniciar o sistema ? [S] ou [N]'))\n",
        "\n",
        "while continuar.upper() != 'S' and continuar.upper() != 'N':\n",
        "  print('Opção invalida')\n",
        "  continuar = print(input('Deseja iniciar o sistema ? [S] ou [N]'))\n",
        "\n",
        "totaldoadores = 0\n",
        "totalMasc = 0\n",
        "totalFem = 0\n",
        "doacoes_perdidas = 0\n",
        "\n",
        "while continuar.upper() =='S':\n",
        "  totaldoadores +=1\n",
        "  nome = input('Informe seu nome')\n",
        "  sexo = input('Informe seu sexo: [M] ou [F]')\n",
        "\n",
        "  while sexo.upper() != 'F' and sexo.upper() != 'M':\n",
        "    print('Opção invalida')\n",
        "    sexo = input('Informe seu sexo')\n",
        "\n",
        "  #doadores por sexo\n",
        "  if sexo.upper() =='M':\n",
        "    totalMasc += 1\n",
        "  \n",
        "  elif sexo.upper() =='F':\n",
        "    totalFem +=1\n",
        "\n",
        "  tamanhoMecha = int(input('Qual o tamanho da mecha em cm ?: '))\n",
        "\n",
        "  #validando tamanho\n",
        "  if tamanhoMecha < 10:\n",
        "    print('Para doação a mecha deve possuir no minimo 10cm ')\n",
        "    print('Espere seu cabelo crescer mais um pouco')\n",
        "    doacoes_perdidas +=1\n",
        "  \n",
        "  #validando se a mexa tocou no chao\n",
        "  else:\n",
        "    caiu_chao = str(input(print('Os cabelos cairam no chão durante o processo ? [S] ou [N] ')))\n",
        "    while caiu_chao.upper() != 'S' and caiu_chao.upper() != 'N':\n",
        "      print('Opção invalida')\n",
        "      caiu_chao = str(input(print('Os cabelos cairam no chão durante o processo ? [S] ou [N] ')))\n",
        "\n",
        "  \n",
        "    if caiu_chao.upper() == 'S':\n",
        "      print('Infelizmente para a doação a mecha não pode ter caido no chao ')\n",
        "      doacoes_perdidas +=1\n",
        "  \n",
        "  #validando doença capilar\n",
        "    else:\n",
        "      doença_capilar = str(input('O doador possui alguma doença capilar ? [S] ou [N]'))\n",
        "      while doença_capilar.upper() != 'S' and doença_capilar.upper() != 'N':\n",
        "        print('Opção invalida')\n",
        "        doença_capilar = str(input('O doador possui alguma doença capilar ? [S] ou [N]'))\n",
        "      \n",
        "      if doença_capilar.upper() =='S':\n",
        "        print('Infelizmente doador com doença capilar não pode fazer uma doação')\n",
        "        doacoes_perdidas +=1\n",
        "      \n",
        "      else:\n",
        "        armazenamento = str(input('Os dados foram guardados corretamente ? [S] ou [N]'))\n",
        "        while armazenamento.upper() != 'S' and armazenamento.upper()!= 'N':\n",
        "          print('Opção invalida')\n",
        "          armazenamento = str(input('Os dados foram guardados corretamente ? [S] ou [N]'))\n",
        "        \n",
        "    #validando armazenamento\n",
        "\n",
        "        if armazenamento.upper() =='N':\n",
        "          print('Infelizmente não poderemos continuar com sua doação por conta do armazenamento')\n",
        "          doacoes_perdidas +=1\n",
        "\n",
        "  continuar = str(input('Deseja iniciar o sistema ? [S] ou [N]'))\n",
        "  while continuar.upper() != 'N' and continuar.upper() != 'S':\n",
        "    print('Opção invalida')\n",
        "    continuar = print(input('Deseja iniciar o sistema ? [S] ou [N]'))\n",
        "\n",
        "\n",
        "else:\n",
        "  print('\\n RELATORIO FINAL \\n') \n",
        "\n",
        "print('Total de doações: ',totaldoadores)    \n",
        "print('Total de doações perdidas: ',doacoes_perdidas) \n",
        "print('Total de doações valida: ',totaldoadores-doacoes_perdidas)   \n",
        "print('Porcentagem de participantes do sexo feminino: ', (totalFem*100 / totaldoadores), '%')  \n",
        "print('Porcentagem de participantes do sexo masculino: ', (totalMasc*100 / totaldoadores), '%')\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "  "
      ],
      "execution_count": 141,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Deseja iniciar o sistema ? [S] ou [N]s\n",
            "Informe seu nometiago\n",
            "Informe seu sexo: [M] ou [F]m\n",
            "Qual o tamanho da mecha em cm ?: 40\n",
            "Os cabelos cairam no chão durante o processo ? [S] ou [N] \n",
            "n\n",
            "O doador possui alguma doença capilar ? [S] ou [N]n\n",
            "Os dados foram guardados corretamente ? [S] ou [N]s\n",
            "Deseja iniciar o sistema ? [S] ou [N]s\n",
            "Informe seu nomemaico\n",
            "Informe seu sexo: [M] ou [F]m\n",
            "Qual o tamanho da mecha em cm ?: 2\n",
            "Para doação a mecha deve possuir no minimo 10cm \n",
            "Espere seu cabelo crescer mais um pouco\n",
            "Deseja iniciar o sistema ? [S] ou [N]s\n",
            "Informe seu nomefarias\n",
            "Informe seu sexo: [M] ou [F]m\n",
            "Qual o tamanho da mecha em cm ?: 41\n",
            "Os cabelos cairam no chão durante o processo ? [S] ou [N] \n",
            "n\n",
            "O doador possui alguma doença capilar ? [S] ou [N]n\n",
            "Os dados foram guardados corretamente ? [S] ou [N]s\n",
            "Deseja iniciar o sistema ? [S] ou [N]s\n",
            "Informe seu nomeronnan\n",
            "Informe seu sexo: [M] ou [F]m\n",
            "Qual o tamanho da mecha em cm ?: 10\n",
            "Os cabelos cairam no chão durante o processo ? [S] ou [N] \n",
            "s\n",
            "Infelizmente para a doação a mecha não pode ter caido no chao \n",
            "Deseja iniciar o sistema ? [S] ou [N]s\n",
            "Informe seu nomekarol\n",
            "Informe seu sexo: [M] ou [F]f\n",
            "Qual o tamanho da mecha em cm ?: 30\n",
            "Os cabelos cairam no chão durante o processo ? [S] ou [N] \n",
            "n\n",
            "O doador possui alguma doença capilar ? [S] ou [N]n\n",
            "Os dados foram guardados corretamente ? [S] ou [N]s\n",
            "Deseja iniciar o sistema ? [S] ou [N]n\n",
            "\n",
            " RELATORIO FINAL \n",
            "\n",
            "Total de doações:  5\n",
            "Total de doações perdidas:  2\n",
            "Total de doações valida:  3\n",
            "Porcentagem de participantes do sexo feminino:  20.0 %\n",
            "Porcentagem de participantes do sexo masculino:  80.0 %\n"
          ]
        }
      ]
    }
  ]
}