Cópia_de_Aula_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "bzLToluSqDDF",
        "xe_4RygbkuKP",
        "89zMM9VtjQvp"
      ],
      "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/nadiduno/linkColabGoogle/blob/main/C%C3%B3pia_de_Aula_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **AULA 01 - PYTHON**\n",
        "## **Martha Cabel** 😎"
      ],
      "metadata": {
        "id": "bzLToluSqDDF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Recomendações:\n",
        "\n",
        "[Melhor Forma de Aprender Python (Google Colab Notebook)](https://youtu.be/Gojqw9BQ5qY)\n",
        "\n",
        "[Python no W3Schools](https://www.w3schools.com/python/default.asp)\n",
        "\n",
        "[Projeto Jupyter](https://jupyter.org/)"
      ],
      "metadata": {
        "id": "xe_4RygbkuKP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Operações Aritméticas\n",
        "\n",
        "`+` (adição)\n",
        "\n",
        "`-` (subtração)\n",
        "\n",
        "`*` (multiplicação)\n",
        "\n",
        "`/` (divisão)\n",
        "\n",
        "`**` (potência)\n",
        "\n",
        "`%` (resto de divisão, modulus)\n",
        "\n",
        "`//` (arredonda a divisão (Floor Division), deixa sem número quebrado)\n"
      ],
      "metadata": {
        "id": "hvV1cX3UX5ST"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Adição\n",
        "2+2"
      ],
      "metadata": {
        "id": "yHSaJFh4nekY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dc7fed34-0a35-4611-c2e0-36e01e3836bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Subtração\n",
        "2-2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HK9n8aF4ng8I",
        "outputId": "90266704-0fca-4c32-f85e-7663b1f254cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiplicação\n",
        "2*3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UTcKOHkenizb",
        "outputId": "14e0cba3-dad5-46cd-c903-a74eb833e63d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Divisão\n",
        "2/2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3S8Pul2Ynkt7",
        "outputId": "14f5d735-eba4-444d-d71a-e8796ab3a986"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Potência\n",
        "3**2\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1JkHCmgMop2c",
        "outputId": "62a65602-46c1-49cc-9938-d6da291aa5e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Modulus\n",
        "2 % 2"
      ],
      "metadata": {
        "id": "HpSkE2T5pMjW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b32daeef-7481-4e92-ee76-a5798b8c74dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Arredonda (Floor Division)\n",
        "5 // 2 "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iixkNYvaZlw_",
        "outputId": "ab7eb395-238e-497c-e4d3-a17359de56a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 153
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variáveis\n",
        "\n",
        "Variáveis são dados que podemos atribuir um nome.\n",
        "\n",
        "Podemos chamar os dados registrados ao longo do código pelos seus respectivos nomes.\n",
        "\n",
        "Assim como também criar qualquer tipo de nome que desejarmos para elas.\n",
        "\n",
        "## Variáveis Primitivas\n",
        "\n",
        "Possuem um **único** valor armazenado.\n",
        "\n",
        "- Integer (Int) > números com valores inteiros, sem vírgula\n",
        "- Float (Real) > números com valores flutuantes, com vírgula\n",
        "- Boolean (Lógico) > valores verdadeiros e falsos\n",
        "- String (Caracteres) > valores em texto\n",
        "\n",
        "## Variáveis Compostas\n",
        "\n",
        "Possuem **mais de um** valor armazenado.\n",
        "\n",
        "- Listas, Arrays e Tuples > São uma sequência de valores ordenados de forma linear.\n",
        "\n",
        "- Matriz > É um conjunto de listas com sublistas\n",
        "\n",
        "- Dicionário, Objeto > São uma sequência de valores categorizada e ordenada em uma determinada sequência e instânciados a partir de uma classe ou constructor.\n",
        "\n"
      ],
      "metadata": {
        "id": "89zMM9VtjQvp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variáveis Primitivas\n",
        "---"
      ],
      "metadata": {
        "id": "wo8uj0dMDGLa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inteiro = 2\n",
        "\n",
        "print(inteiro)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ByWDewXSmC1y",
        "outputId": "694afa90-b255-4b28-cf6c-032ca24fe76e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "flutuante = 3.5\n",
        "print(flutuante)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5bsYuTtXrlX-",
        "outputId": "03219440-bc5b-4bdf-a2b2-d4df53e01fd7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Soma igual a 3\n",
        "soma = 1 + 2\n",
        "\n",
        "# Soma é igual a 3? Sim! Então é verdadeiro\n",
        "print(\"A soma é:\", soma == 3)\n",
        "\n",
        "# Subtração é igual a -1 \n",
        "subtracao = 1 - 2\n",
        "\n",
        "# Subtração é igual a 0? Não! Então é falso\n",
        "print(\"A subtração é:\", subtracao == 0)\n",
        "\n",
        "logico = True\n",
        "\n",
        "print(\"O meu lógico é: %s\" %logico)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dc582841-07e1-4198-bb26-bfa8b49f9d33",
        "id": "wDY_3PtNsu3C"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A soma é: True\n",
            "A subtração é: False\n",
            "O meu lógico é: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "string = \"Olá, sou uma frase que tem o tipo string\"\n",
        "\n",
        "print(string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4XRAcvx5vdWq",
        "outputId": "869cc69a-eb4b-4ef0-df99-7cd140ca2932"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Olá, sou uma frase que tem o tipo string\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variáveis Compostas\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "Xmkx15M6C7pf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Listas podem ser usadas como arrays\n",
        "lista = [1, 2, 3, 4, 5, 6, \"oi\"]\n",
        "listaDois = list((6, 5, 4, 3, 2, 1))\n",
        "\n",
        "print(lista)\n",
        "print(listaDois)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DX-MLjCg88GG",
        "outputId": "154f7920-0078-4cc1-87f2-a60c68f576e9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5, 6, 'oi']\n",
            "[6, 5, 4, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Para usar Arrays, é preciso usar a biblioteca NumPy\n",
        "# https://www.w3schools.com/python/numpy/default.asp\n",
        "import numpy as np\n",
        "meuArray = np.array([1, 2, 3, 4, 5, 6])\n",
        "print(\"Meu array: \", meuArray)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XVpbshOn-D1k",
        "outputId": "f2cd1acf-6ad8-4bf1-e2a3-e70726e990e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Meu array:  [1 2 3 4 5 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Objetos podem ter mais de uma propriedade\n",
        "# No exemplo abaixo, existem vários países (propriedades)\n",
        "# Com bandeiras (classe dos objetos)\n",
        "# Os objetos serão acompanhados com classes no Python \n",
        "class Bandeira:\n",
        "  UM = \"Inglaterra\"\n",
        "  DOIS = \"Espanha\"\n",
        "  TRES = \"França\"\n",
        "  \n",
        "nomePais = Bandeira()\n",
        "print(nomePais.UM)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wJ6nQcUYF4gK",
        "outputId": "b0d13594-6aaf-4619-f5d6-8c351525f513"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Inglaterra\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8TEhZkDbpRQW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Index\n",
        "Index mostra **separadamente** os caracteres de uma string \n",
        "\n",
        "Como também mostra os valores de uma variável composta.\n",
        "\n",
        "- O index ***sempre começa*** com 0. Nunca começamos com 1.\n",
        "\n",
        "# Index na prática\n",
        "---"
      ],
      "metadata": {
        "id": "ajewT5IHFw-8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Variável com nome de lista e valor de string\n",
        "PegarIndex = \"Hey, sou uma string! Pegue o meu index\"\n",
        "\n",
        "# Index das três primeiras letras da string na saída (output)\n",
        "# Index SEMPRE começa com ZERO\n",
        "print(\"Os três primeiros caracteres: \" + \n",
        "      PegarIndex[0], PegarIndex[1], PegarIndex[2])\n",
        "\n",
        "# Index do número de caracteres e a última letra do PegarIndex\n",
        "# Obs: Os espaços contam como caracter\n",
        "charTotal = len(PegarIndex) -1\n",
        "charUltima = PegarIndex[-1]\n",
        "  # Este também funciona: PegarIndex[len(PegarIndex) -1]\n",
        "\n",
        "# Lista todos os caracteres a partir do index (uso de spliting)\n",
        "charFraseCompleta = PegarIndex[0:]\n",
        "\n",
        "print(\"O total de caracteres da string: \" + str(charTotal))\n",
        "print(\"O último caracter da string: \" + charUltima)\n",
        "print(\"A frase inteira é: \" + charFraseCompleta)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "po-DCcyOwVgZ",
        "outputId": "2f79c6fe-9fa1-4a08-d596-be83306b9824"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Os três primeiros caracteres: H e y\n",
            "O total de caracteres da string: 37\n",
            "O último caracter da string: x\n",
            "A frase inteira é: Hey, sou uma string! Pegue o meu index\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Inputs \n",
        "\n",
        "inputs são usados para coletar informações do usuário\n",
        "\n",
        "Usamos os inputs para guardar dados não antes definidos no código\n",
        "\n",
        "- É necessário converter para um outro tipo de dado se diferente de string"
      ],
      "metadata": {
        "id": "YU_zWnLHRalc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "variavel = int(input(\"Escolha um número para somar com DOIS: \"))\n",
        "\n",
        "# Exemplo de um output que exibirá um erro\n",
        "# print (\"O resultado foi:\" + variavel + 2)\n",
        "\n",
        "# Exemplo de um output correto\n",
        "print(\"O resultado foi: \" + str(variavel + 2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FTLjtjkPTHD2",
        "outputId": "635d17f9-c6a1-4d15-913a-ef4da6d89532"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escolha um número para somar com DOIS: 9\n",
            "O resultado foi: 11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Funções\n",
        "\n",
        "Funções funcionam como uma forma de guardar resultados calculados das variáveis\n",
        "\n",
        "- Não precisamos mais repetir o cálculo ou a organização com as funções\n",
        "\n",
        "- Podemos assim separar o código com blocos fechados\n",
        "\n",
        "- Os blocos das funções só são executados se chamados pelo código\n",
        "\n",
        "- Podemos fazer as funções esperarem a entrada de variáveis (parâmetros)\n",
        "\n",
        "  - Quando definido parâmetros, a função precisa retornar um resultado\n",
        "\n",
        "## Sintaxe da Função\n",
        "\n",
        "---\n",
        "\n",
        "`def` - Define a função\n",
        "\n",
        "`nomeFuncao` - Nome do bloco da função\n",
        "\n",
        "`(parametro1, parametro2)` - Variáveis necessárias para o bloco (opcional)\n",
        "\n",
        "`:` - Sinal de dois pontos define o início da função\n",
        "\n",
        "`nomeFuncao()` - Executa a função criada"
      ],
      "metadata": {
        "id": "YMSz58RKG0bX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def nomeFuncao(): \n",
        "      print(1 + 2)\n",
        "nomeFuncao()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1XsW2GTVGzpN",
        "outputId": "d82814fd-3984-42ea-c30d-b2885a454e5d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def somaDoisParametros(varInt1, varInt2):\n",
        "  # Este é o corpo da função\n",
        "  # Use tab para criar espaçamento\n",
        "  # O espaçamento diz o que está dentro da função\n",
        "  # Obs: os parâmetros somente representam as variáveis\n",
        "  return varInt1 + varInt2\n",
        "\n",
        "num1 = int(input(\"Número 1: \"))\n",
        "num2 = int(input(\"Número 2: \"))\n",
        "\n",
        "output = somaDoisParametros(num1, num2)\n",
        "print(output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O_nGwPqmUdMu",
        "outputId": "0ecefc50-9ce7-45da-ccc7-715fa15b4232"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Número 1: 60\n",
            "Número 2: 40\n",
            "100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variáveis Globais e Locais\n",
        "\n",
        "As variáveis ***globais*** ficam fora dos blocos das funções\n",
        "  - Elas são reconhecidas em qualquer lugar dentro do arquivo\n",
        "\n",
        "As variáveis ***locais*** só são reconhecidas dentro das suas respectivas funções\n",
        " - Não podemos chamá-las fora das funções"
      ],
      "metadata": {
        "id": "fO3AyMLAeprM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "meuNumeroFavorito = 9\n",
        "meuNumeroFavorito"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tbr85z5sfOvS",
        "outputId": "758134b0-b542-43ad-b4d7-618e70ccdcb7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "meuNumeroFavorito + 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n6ouvGOVfdRZ",
        "outputId": "039d1253-51a2-4537-83c5-5ed5b6dc5859"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 161
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Verifica se o número existe fora do escopo da função\n",
        "numero = 2\n",
        "def meuNumero() :\n",
        "  numero = 9\n",
        "# Verifica dentro do escopo da função\n",
        "  if \"numero\" in locals():\n",
        "   print(\"número local existe. Ele é: \" + str(numero))\n",
        "  else:\n",
        "   print(\"número não existe\")\n",
        "\n",
        "# Verifica fora dos escopos das funções\n",
        "if \"numero\" in globals():\n",
        "   print(\"número global existe. Ele é: \" + str(numero))\n",
        "else:\n",
        "   print(\"número não existe\")\n",
        "\n",
        "# Chamada da função\n",
        "meuNumero()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7x3ubAwxfilW",
        "outputId": "e8867339-f40a-44df-aae1-9df673bd6e35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "número global existe. Ele é: 2\n",
            "número local existe. Ele é: 9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "```\n",
        "# This is formatted as code\n",
        "```\n",
        "\n",
        "# Exercícios\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "whXA9qhBbfvU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercício sobre média de quatro notas\n",
        "\n",
        "def calc_media (nota1, nota2, nota3, nota4):\n",
        "  media = (nota1 + nota2 + nota3 + nota4)/4\n",
        "  return media\n",
        "\n",
        "p1 = int(input(\"digite a nota 1 aqui:\"))\n",
        "p2 = int(input(\"digite a nota 2 aqui:\"))\n",
        "p3 = int(input(\"digite a nota 3 aqui:\"))\n",
        "p4 = int(input(\"digite a nota 4 aqui:\"))\n",
        "\n",
        "print(calc_media(p1, p2, p3, p4))"
      ],
      "metadata": {
        "id": "3m9bVkZGXwwk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6438969d-f8cb-4194-89ef-b68d77006b7c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "digite a nota 1 aqui:100\n",
            "digite a nota 2 aqui:75\n",
            "digite a nota 3 aqui:82\n",
            "digite a nota 4 aqui:86\n",
            "85.75\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercício sobre conversão de fahrenheit para celsius\n",
        "def FtoC(varF):\n",
        "  varC = (varF -32) / 1.8\n",
        "  return varC\n",
        "\n",
        "Fahrenheit = float(input(\"Digite o valor da tempetatura em Fahrenheit: \"))\n",
        "\n",
        "print(FtoC(Fahrenheit))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SodS07hpm76Y",
        "outputId": "a68214c8-5cd6-4f27-9eb4-525fe505273c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digite o valor da tempetatura em Fahrenheit: 100\n",
            "37.77777777777778\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **AULA 02 - PYTHON**\n",
        "## **Martha Cabel** 😎"
      ],
      "metadata": {
        "id": "4zqBRE_4Xlos"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Operações Relacionais \n",
        "### *(Comparison Operators)*\n",
        "\n",
        "**Lembra do Boolean?**\n",
        "\n",
        "É aqui que começamos a usar os valores Booleanos na hora de programar.\n",
        "\n",
        "`==` (Igual)\n",
        "\n",
        "`!=` (Não Igual)\n",
        "\n",
        "`>` (Maior que)\n",
        "\n",
        "`<` (Menor que)\n",
        "\n",
        "`>=` (Maior ou igual a)\n",
        "\n",
        "`<=` (Menor ou igual a)\n"
      ],
      "metadata": {
        "id": "d7ZlU_rHqVIa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Igual\n",
        "logico = 3 == 3\n",
        "print(\"O lógico é: \" + str(logico))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0I5fViar5izt",
        "outputId": "34209f4b-337b-461a-a032-238a7f95a108"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O lógico é: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Não Igual\n",
        "logico = 3 != 3\n",
        "print(\"O lógico é: \" + str(logico))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HYEabPlS5sJi",
        "outputId": "743163e3-9057-42e7-8f55-6bd676062636"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O lógico é: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Maior que \n",
        "logico = 3 > 4\n",
        "print(\"O lógico é: \" + str(logico))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "03Egog_qgDQH",
        "outputId": "726aff87-615f-4039-a054-b6370a94b890"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O lógico é: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Menor que\n",
        "logico = 3 < 4\n",
        "print(\"O lógico é: \" + str(logico))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LafOohCBhxc8",
        "outputId": "da159014-6fde-4389-9114-32e7bfb645c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O lógico é: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Maior ou igual\n",
        "logico = 5 >= 3\n",
        "print(\"O lógico é: \" + str(logico))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dvQhRmyy5xO3",
        "outputId": "1aaec71a-3fb8-43e8-c1c7-a7479140b874"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O lógico é: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Menor ou igual\n",
        "logico = 5 <= 3\n",
        "print(\"O lógico é: \" + str(logico))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QLmCj2_Qh9RW",
        "outputId": "02802471-6a48-4619-b3e4-507c3be36a73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O lógico é: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Operadores Lógicos\n",
        "\n",
        "`not` **Inverso** (considera o lógico *diferente* do outro da relação)\n",
        "\n",
        "`and` **E** (considera um lógico *E* mais um outro da relação)\n",
        "\n",
        "`or` **OU** (considera um lógico *OU* outro da relação)\n",
        "\n",
        "# Tabela Verdade\n",
        "\n",
        "## NOT\n",
        "\n",
        "---\n",
        "\n",
        "| p     | not p      | \n",
        "|------ |:---------:|   \n",
        "| True  | False   |  \n",
        "| False | True    |\n",
        "\n",
        "## E\n",
        "\n",
        "---\n",
        "\n",
        "| p     | q         | p and q       |\n",
        "|------ |:----------:|-------------:|\n",
        "| True  | True      | True        |\n",
        "| True  | False     | False       |\n",
        "| False | True      | False       |\n",
        "| False | False     | False       |\n",
        "                   \n",
        "\n",
        "## OU\n",
        "\n",
        "---\n",
        "\n",
        "| p     | q         | p or q       |\n",
        "|------ |:----------:|-------------:|\n",
        "| True  | True      | True        |\n",
        "| True  | False     | True        |\n",
        "| False | True      | True        |\n",
        "| False | False     | False       |\n",
        "\n",
        "\n",
        "# Operadores Bitwise\n",
        "\n",
        "Funcionam de forma semelhante aos operadores lógicos.\n",
        "\n",
        "A diferença é que o resultado lógico (True/False)\n",
        "\n",
        "É transformado em binário/bit (1/0).\n",
        "\n",
        "- Obs: Bitwire faz exatamente TODA a análise lógica em binários.\n",
        "- Portanto, dependendo do operador usado a resposta varia.\n",
        "\n",
        "`~` **Inverso** \n",
        "\n",
        "(output/resultado **inverso** dos bits)\n",
        "- Obs: NOT em Bitwise na prática **não é** a mesma coisa que NOT em Lógico\n",
        "  - O inverso de True (1) é: -2 \n",
        "  - O inverso de False (0) é: -1\n",
        "\n",
        "  - Exemplo em bits: \n",
        "   - `7 == 0 1 1 1`\n",
        "   - `~7 (~0 1 1 1) = 1 0 0 0`\n",
        "   - `~7 = 8`\n",
        "\n",
        "`&` **E** \n",
        "\n",
        "(output/resultado **1** se um bit e outro forem verdadeiros)\n",
        "- Obs: a comparação lógica só funciona entre dois bits.\n",
        "\n",
        "`|` **OU** \n",
        "\n",
        "(output/resultado **1** se um bit ou outro for verdadeiro)\n",
        "- Obs: a comparação lógica só funciona entre dois bits.\n",
        "\n"
      ],
      "metadata": {
        "id": "E-1fq-11n_8C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Na prática\n",
        "boolFalse = 7 != 7\n",
        "boolTrue = 7 > 4\n",
        "booleanoInverso = ~ 7\n",
        "#----------------------------------------------\n",
        "# Not\n",
        "booleanoNOT = not boolTrue\n",
        "print(\"2-Booleano NOT: \" + str(booleanoNOT))\n",
        "\n",
        "# != É Operador Relacional\n",
        "booleanoNOT =  boolFalse != boolFalse\n",
        "print(\"1-Booleano Relacional NOT: \" + str(booleanoNOT))\n",
        "\n",
        "# IS e IS NOT são Operadores de Identidade \n",
        "booleanoNOT = boolFalse is not boolTrue\n",
        "print(\"3-Booleano Identidade NOT: \" + str(booleanoNOT))\n",
        "\n",
        "\n",
        "# Obs: NOT em Bitwire na prática não é a mesma coisa que NOT em Lógico\n",
        "print(\"4-Booleano Bitwise NOT: \" + str(booleanoInverso))\n",
        "#----------------------------------------------\n",
        "#----------------------------------------------\n",
        "print(\"------\")\n",
        "#----------------------------------------------\n",
        "#----------------------------------------------\n",
        "# E\n",
        "booleanoAND = boolFalse and boolTrue\n",
        "print(\"1-Booleano AND: \" + str(booleanoAND))\n",
        "\n",
        "# & É Operador Bitwise\n",
        "booleanoAND = boolFalse & boolTrue\n",
        "print(\"2-Booleano Bitwise AND: \" + str(booleanoAND))\n",
        "#----------------------------------------------\n",
        "#----------------------------------------------\n",
        "print(\"------\")\n",
        "#----------------------------------------------\n",
        "#----------------------------------------------\n",
        "# OU\n",
        "booleanoOR = boolFalse or boolTrue\n",
        "print(\"1-Booleano OR: \" + str(booleanoOR))\n",
        "\n",
        "# | É Operador Bitwise\n",
        "booleanoOR = boolFalse | boolTrue\n",
        "print(\"2-Booleano Bitwise OR: \" + str(booleanoOR))\n",
        "#----------------------------------------------"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YHXAejvRp0Qt",
        "outputId": "5e66bc8d-94fb-4ec6-c67c-cd5a5cad95eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2-Booleano NOT: False\n",
            "1-Booleano Relacional NOT: False\n",
            "3-Booleano Identidade NOT: True\n",
            "4-Booleano Bitwise NOT: -8\n",
            "------\n",
            "1-Booleano AND: False\n",
            "2-Booleano Bitwise AND: False\n",
            "------\n",
            "1-Booleano OR: True\n",
            "2-Booleano Bitwise OR: True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Condicionais\n",
        "\n",
        "Condicionais permitem a programação acontecer!\n",
        "\n",
        "Usamos elas para variar valores e respostas em nosso código\n",
        "\n",
        "## IF | ELIF | ELSE\n",
        "---\n",
        "\n",
        "`IF` - (SE) \n",
        "- Analisa se a relação é verdadeira ou falsa.\n",
        "\n",
        "`ELIF` - (SENÃO SE) \n",
        "- Caso o IF não for verdade, o ELIF verifica outra condição.\n",
        "\n",
        "`ELSE` - (SENÃO) \n",
        "- Caso o IF e nem o ELFI não forem verdade, o else é usado como último caso."
      ],
      "metadata": {
        "id": "sYJHsyHC6RdP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ------------------------------------\n",
        "# Condicionais IF, ELFI e ELSE\n",
        "# ------------------------------------\n",
        "# Analisando números pares e ímpares\n",
        "# ------------------------------------\n",
        "valor = int(input(\"Escolha um número: \"))\n",
        "\n",
        "if valor == 0:\n",
        " print(\"O valor é zero! Mas é par :D\")\n",
        "elif valor % 2 == 0:\n",
        "   print(\"É par\")\n",
        "else:\n",
        "   print(\"É ímpar\")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JIT5g0y86RM5",
        "outputId": "6bfcb36f-3a30-4224-8dbf-b68eb02aed49"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escolha um número: 5\n",
            "É ímpar\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# IF ANINHADO\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "EYele5jP86KA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ------------------------------------\n",
        "# IF ANINHADO\n",
        "# ------------------------------------\n",
        "# IFs podem acompanhar outros IFs.\n",
        "# Precisa somente identar para colocar\n",
        "# um IF dentro de outro IF\n",
        "# ------------------------------------\n",
        "# Exemplo:\n",
        "valor = int(input(\"Escolha um número: \"))\n",
        "\n",
        "if valor < 10:\n",
        "    if(valor < 5):\n",
        "     print(valor - 5)\n",
        "    else:\n",
        "       print(valor + 5)\n",
        "else:\n",
        "    print(valor // 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bxrMZxP3889N",
        "outputId": "9eda017a-1082-4b6a-a726-72e588f8bc97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escolha um número: 20\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# LOOPS\n",
        "\n",
        "Loops são iterações (repetições) que queremos\n",
        "que nosso código repita até certo ponto\n",
        "\n",
        "- Obs: Tenha cuidado para não criar loops infinitos\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "eMGQ2w7G-bJi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> ## WHILE\n"
      ],
      "metadata": {
        "id": "ULUUeRobHPVw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ------------------------------------\n",
        "# Condicional WHILE\n",
        "# ------------------------------------\n",
        "# Analisando número de caracteres\n",
        "# ------------------------------------\n",
        "\n",
        "# ------------------------------------\n",
        "# Variáveis\n",
        "# ------------------------------------\n",
        "frase = \"Três pratos de trigo para três tigres tristes\"\n",
        "contador = 0\n",
        "i = 0  \n",
        "\n",
        "# ------------------------------------\n",
        "# Input da letra desejada\n",
        "# ------------------------------------\n",
        "letra = input(\"Qual letra você quer saber quantas tem? \")\n",
        "letra_maiuscula = letra.upper()\n",
        "letra_minuscula = letra.lower()\n",
        "\n",
        "# ------------------------------------\n",
        "# Iteração com condicional IF\n",
        "# ------------------------------------\n",
        "while i < len(frase):\n",
        "  if frase[i] == letra_maiuscula or frase[i] == letra_minuscula:\n",
        "    contador += 1\n",
        "  i += 1\n",
        "  # i = i + 1\n",
        "\n",
        "# ------------------------------------\n",
        "# Resultado final\n",
        "# ------------------------------------\n",
        "print(\"A frase tem: \", str(contador), letra_maiuscula + \"s\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KhPp_MKN-eib",
        "outputId": "5fed35aa-79fa-45da-a16c-5f66e15499b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Qual letra você quer saber quantas tem? t\n",
            "A frase tem:  7 Ts\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ------------------------------------\n",
        "# Condicional WHILE\n",
        "# ------------------------------------\n",
        "# Analisando número de caracteres \n",
        "# com BREAK\n",
        "# ------------------------------------\n",
        "\n",
        "# ------------------------------------\n",
        "# Variáveis\n",
        "# ------------------------------------\n",
        "frase = \"Três pratos de trigo para três tigres tristes\"\n",
        "contador = 0\n",
        "i = 0\n",
        "\n",
        "# ------------------------------------\n",
        "# Input da letra desejada\n",
        "# ------------------------------------\n",
        "letra = input(\"Qual letra você quer saber onde achar primeiro? \")\n",
        "\n",
        "# ------------------------------------\n",
        "# Iteração com condicional IF e BREAK\n",
        "# ------------------------------------\n",
        "while i < len(frase):\n",
        "  if frase[i] == letra:\n",
        "    contador += 1\n",
        "    break\n",
        "  i += 1\n",
        "\n",
        "# ------------------------------------\n",
        "# Resultado final com IF e ELSE\n",
        "# ------------------------------------\n",
        "if (contador == 0):\n",
        "  print(\"A letra mencionada não existe. :(\")\n",
        "else:\n",
        "  print(\"A letra está na posição: \", str(i + 1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2WOXYy73CyzG",
        "outputId": "1682b257-3ce4-431b-c146-ea0ead1cd087"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Qual letra você quer saber onde achar primeiro? z\n",
            "A letra mencionada não existe. :(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> ## FOR"
      ],
      "metadata": {
        "id": "8xs2Vb0fHhQj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ------------------------------------\n",
        "# Condicional FOR\n",
        "# ------------------------------------\n",
        "# Analisando número de caracteres \n",
        "# ------------------------------------\n",
        "\n",
        "# ------------------------------------\n",
        "# Variáveis\n",
        "# ------------------------------------\n",
        "frase = \"Três pratos de trigo para três tigres tristes\"\n",
        "contador = 0\n",
        "\n",
        "\n",
        "# ------------------------------------\n",
        "# Input da letra desejada\n",
        "# ------------------------------------\n",
        "letra = input(\"Qual letra você quer saber quantas tem? \")\n",
        "letra_maiuscula = letra.upper()\n",
        "letra_minuscula = letra.lower()\n",
        "\n",
        "# ------------------------------------\n",
        "# Iteração com condicional IF\n",
        "# ------------------------------------\n",
        "for i in frase:\n",
        "  if i == letra_maiuscula or i == letra_minuscula:\n",
        "    contador += 1\n",
        "\n",
        "# ------------------------------------\n",
        "# Resultado final\n",
        "# ------------------------------------\n",
        "print(\"A frase tem: \", str(contador), letra_maiuscula + \"s\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ncjPJdUuFdqH",
        "outputId": "650cdf04-2358-4e26-c2d5-598a9a25891c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Qual letra você quer saber quantas tem? t\n",
            "A frase tem:  7 Ts\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ------------------------------------\n",
        "# Condicional FOR\n",
        "# ------------------------------------\n",
        "# Analisando listas e arranjos\n",
        "# ------------------------------------\n",
        "\n",
        "lista = [1, 2, 3, 4, 5, 6]\n",
        "\n",
        "for i in lista:\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fSXl7HjzFWFq",
        "outputId": "7985a208-7237-4097-a9d9-1316a9b7b4ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# RANGE\n",
        "\n",
        "Retorna uma sequência de números específica\n",
        "- Podemos adicionar intervalos (passos do index) \n",
        "- Portanto teremos até 3 valores no range()\n",
        " - range(começo, fim, intervalo)"
      ],
      "metadata": {
        "id": "h9iARKDYH0cN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "meuArranjo = range(0, 10, 2)\n",
        "for i in meuArranjo:\n",
        "  print(i, end=\" \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FNmPBuU8F53y",
        "outputId": "6ee1f2dc-0fcd-4b4d-f09c-13dedc551697"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 2 4 6 8 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Lista (Utilidades)\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "g8-8Nr8qKMbt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Adicionar valores\n",
        "#---------------------------------\n",
        "\n",
        "meuArranjo = range(0, 10, 2)\n",
        "minhaLista = [] \n",
        "# Obs: sempre comecem uma lista vazia\n",
        "# caso já não seja preenchido valores\n",
        "\n",
        "#---------------------------------\n",
        "# Adiciona cada elemento na lista\n",
        "# de acordo com o loop FOR\n",
        "#---------------------------------\n",
        "for i in meuArranjo:\n",
        "  minhaLista.append(i)\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "print(minhaLista)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y-xX9oDbOVP-",
        "outputId": "0598e658-4cd1-4a8a-906d-4948cf1d0833"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 2, 4, 6, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Remover valores\n",
        "#---------------------------------\n",
        "\n",
        "meuArranjo = range(0, 10, 2)\n",
        "minhaLista = []\n",
        "\n",
        "for i in meuArranjo:\n",
        "  minhaLista.append(i)\n",
        "\n",
        "#---------------------------------\n",
        "# Remove o elemento\n",
        "#---------------------------------\n",
        "minhaLista.remove(4)\n",
        "#---------------------------------\n",
        "# Remove pelo index\n",
        "#---------------------------------\n",
        "minhaLista.pop(0)\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "print(minhaLista)"
      ],
      "metadata": {
        "id": "_rqf-u8KKS2n",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b7ce152-73a2-4ddb-b3ff-16f0f950c4e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 6, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Organizar valores\n",
        "#---------------------------------\n",
        "minhaLista = [1, 11, 4, 5, 7, 9, 8, 13, 3, 2]\n",
        "\n",
        "#---------------------------------\n",
        "# Coloca em ordem crescente\n",
        "#---------------------------------\n",
        "minhaLista.sort()\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "print(minhaLista)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2tEhU5oBP-6U",
        "outputId": "4784a0f5-c6db-40cf-c739-574948aa14f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5, 7, 8, 9, 11, 13]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Encontrar index do elemento\n",
        "#---------------------------------\n",
        "minhaLista = [1, 11, 4, 5, 7, 9, 8, 13, 3, 2]\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "print(minhaLista.index(5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R4L8qHjOQhcQ",
        "outputId": "e6b2c099-d1c6-4bdf-e7c6-5b74c4c8da48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Exibir o index de cada item\n",
        "#---------------------------------\n",
        "minhaLista = [1, 11, 4, 5, 7, 9, 8, 13, 3, 2]\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "for i in minhaLista:\n",
        "  print(minhaLista.index(i), end=\" \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z2M7JrCBTr_O",
        "outputId": "839dac7d-26da-49aa-8dd8-8d95a63c8c92"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Mudar valor pelo index\n",
        "#---------------------------------\n",
        "minhaLista = [1, 11, 4, 5, 7, 9, 8, 13, 3, 2]\n",
        "\n",
        "minhaLista[2] = 14\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "print(minhaLista)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V_9L8DgJRDRC",
        "outputId": "0f742b2d-4218-4432-dab1-106f4109c5bf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 11, 14, 5, 7, 9, 8, 13, 3, 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Encontrar valores\n",
        "# mínimos e máximos\n",
        "# Obs: Pode ser feito pelo FOR\n",
        "#---------------------------------\n",
        "minhaLista = [1, 11, 4, 5, 7, 9, 8, 13, 3, 2]\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "print(\"Valor máximo da lista: \" + str(max(minhaLista)))\n",
        "print(\"Valor mínimo da lista: \" + str(min(minhaLista)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1nBbgOBCRVxI",
        "outputId": "a1218a3d-751b-4267-a674-d4e8c399fa0f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Valor máximo da lista: 13\n",
            "Valor mínimo da lista: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#---------------------------------\n",
        "# Somar elementos da lista\n",
        "# Obs: Pode ser feito pelo FOR\n",
        "#---------------------------------\n",
        "minhaLista = [1, 11, 4, 5, 7, 9, 8, 13, 3, 2]\n",
        "\n",
        "#---------------------------------\n",
        "# Resultado\n",
        "#---------------------------------\n",
        "print(\"Soma na lista: \" + str(sum(minhaLista)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Xmhy1XTR3lA",
        "outputId": "b87c3a1a-b67a-4920-adbc-bf7d1fdaea36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Soma na lista: 63\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercícios \n",
        "---"
      ],
      "metadata": {
        "id": "lKd7kDxqmbJ0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercício sobre conversão de fahrenheit para celsius\n",
        "import math \n",
        "# ----------------------------------------------------------\n",
        "# Primeiro importamos a biblioteca math do Python\n",
        "# Veja a documentação do math aqui: \n",
        "# https://docs.python.org/pt-br/3/library/math.html\n",
        "# ----------------------------------------------------------\n",
        "\n",
        "# ----------------------------------------------------------\n",
        "# Esta função faz a conversão da temperatura.\n",
        "# ----------------------------------------------------------\n",
        "\n",
        "def FahrenheitToCelsius(varF) :\n",
        "  varC = (varF -32) / 1.8\n",
        "  result = round_decimals_ceils(varC)\n",
        "  return result\n",
        "\n",
        "# ----------------------------------------------------------\n",
        "# Esta função especifíca as casas decimais depois da vírgula.\n",
        "# \"decimals:int=1\" significa o número de casas que quero\n",
        "# logo após a vírgula. Ou seja, posso colocar outro\n",
        "# número além de 1 (Ex: decimals:int=2).\n",
        "\n",
        "# Obs: As casas decimais não podem ser < 0.\n",
        "# ----------------------------------------------------------\n",
        "\n",
        "def round_decimals_ceils(celcius:float, decimals:int=2):\n",
        "\n",
        "  # ----------------------------------------------------------\n",
        "  # A função math.modf() verifica as casas decimais.\n",
        "  # Ela separa em lista o valor decimal e o valor inteiro.\n",
        "  # ----------------------------------------------------------\n",
        "\n",
        "  ShowMeDecimals = math.modf(celcius)\n",
        "  \n",
        "  # ----------------------------------------------------------\n",
        "  # A programação abaixo verifica\n",
        "  # se o número possui casas decimais > 0. \n",
        "\n",
        "  # Caso sim, mostra somente as casas definidas \n",
        "  # na variável \"decimals\".\n",
        "\n",
        "  # Caso não, usamos a função round() para transformar\n",
        "  # em um número inteiro a temperatura.\n",
        "\n",
        "  # decimals == 0 significa que podemos deixar arrendondado\n",
        "  # todos os valores automaticamente ao definir a variável\n",
        "  # da função \"decimals\" como decimals:int=0.\n",
        "  # ----------------------------------------------------------\n",
        "\n",
        "  if ShowMeDecimals[0] == 0:\n",
        "    return round(celcius)\n",
        "  elif decimals == 0:\n",
        "    return math.ceil(celcius)\n",
        "  else:\n",
        "    factor = 10 ** decimals\n",
        "    return math.ceil(celcius * factor) / factor\n",
        "    # ----------------------------------------------------------    \n",
        "    # Obs:\"decimals\" é o número de casas decimais\n",
        "    # Obs 2: Usar round ao invés de math.ceil\n",
        "    # lhe dará a mesma resposta. Visto que ambos\n",
        "    # são funções que arredondam os números.\n",
        "    # ----------------------------------------------------------\n",
        "# ----------------------------------------------------------\n",
        "# Por fim, digitamos uma temperatura em Fahrenheit no input\n",
        "# e o resultado final é fornecido no print.\n",
        "# ----------------------------------------------------------\n",
        "\n",
        "Fahrenheit = float(input(\"Valor da temperatura em Fahrenheit: \"))\n",
        "print(FahrenheitToCelsius(Fahrenheit))\n"
      ],
      "metadata": {
        "id": "jYKML0PGbjQl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3da871fe-d7b2-4eb9-9822-aeeb6b2fc399"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Valor da temperatura em Fahrenheit: 100\n",
            "37.78\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **AULA 03 - PYTHON**\n",
        "## **Martha Cabel** 😎"
      ],
      "metadata": {
        "id": "Ve36CZl4XoIc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Material Adicional de Suporte\n",
        "\n",
        "- [Veja sobre concatenações aqui](https://www.geeksforgeeks.org/python-string-concatenation/)\n",
        "\n",
        "- [Veja sobre cópia de listas aqui](https://www.geeksforgeeks.org/python-list-copy-method/?ref=gcse)\n",
        "\n",
        "- [Veja sobre dicionários aqui:](https://www.geeksforgeeks.org/python-dictionary/?ref=gcse)\n",
        "\n",
        "- [Veja sobre bibliotecas aqui:](https://www.geeksforgeeks.org/libraries-in-python/)\n",
        "\n",
        "- [Veja sobre try and except statements aqui](https://www.freecodecamp.org/news/python-try-and-except-statements-how-to-handle-exceptions-in-python/)\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "VX9IAuJquEd7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# MATRIZ\n",
        "\n",
        "São listas com várias sublistas\n",
        "  - Possuem mais de uma dimensão"
      ],
      "metadata": {
        "id": "i5XBtyGA_blJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#------------------------------------------------------\n",
        "# Matriz\n",
        "#------------------------------------------------------\n",
        "# Lista de Compras\n",
        "#------------------------------------------------------\n",
        "matriz = [[\"Batata\", 2, 1], [\"Cenoura\", 4], [\"Rabanete\", 8]]\n",
        "#------------------------------------------------------\n",
        "# Print da Cenoura\n",
        "#------------------------------------------------------\n",
        "print(\"Print da cenoura: \" + str(matriz[1][0]) + \"\\n\")\n",
        "#------------------------------------------------------\n",
        "# Print dos valores nas linhas e colunas\n",
        "#------------------------------------------------------\n",
        "row = 0\n",
        "columns = 0\n",
        "count_i = 0\n",
        "count_j = 0\n",
        "for i in matriz:\n",
        "  row += 1\n",
        "  count_i = row\n",
        "  for j in i:\n",
        "    columns += 1\n",
        "    count_j = columns\n",
        "    print(\"Linha: \" + str(count_i) + \"\\nColuna: \" + str(count_j) + \"\\n\")\n",
        "         # + \"\\n\" + str(row), str(columns) + \"\\n\")       \n",
        "#------------------------------------------------------\n",
        "# Print do length de linhas\n",
        "#------------------------------------------------------\n",
        "print(\"total de linhas é: \" + str(len(matriz)) + \"\\n\")\n",
        "#------------------------------------------------------\n",
        "# Print do length de colunas (somente aproximado)\n",
        "#------------------------------------------------------\n",
        "print(\"número máximo de colunas por linha é: \" \n",
        "      + str(len(matriz[0])) + \"\\n\")\n",
        "#------------------------------------------------------\n",
        "# Print do total de colunas\n",
        "#------------------------------------------------------\n",
        "row = 0 \n",
        "columns = 0\n",
        "count = 0\n",
        "for i in matriz:\n",
        "  for j in i:\n",
        "    columns += 1\n",
        "    count = columns\n",
        "print(\"Total de colunas é: \" + str(count))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rpkhZ0eP_qpR",
        "outputId": "30440d20-0e2f-4a17-ca5b-42414731ff4f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Print da cenoura: Cenoura\n",
            "\n",
            "Linha: 1\n",
            "Coluna: 1\n",
            "\n",
            "Linha: 1\n",
            "Coluna: 2\n",
            "\n",
            "Linha: 1\n",
            "Coluna: 3\n",
            "\n",
            "Linha: 2\n",
            "Coluna: 4\n",
            "\n",
            "Linha: 2\n",
            "Coluna: 5\n",
            "\n",
            "Linha: 3\n",
            "Coluna: 6\n",
            "\n",
            "Linha: 3\n",
            "Coluna: 7\n",
            "\n",
            "total de linhas é: 3\n",
            "\n",
            "número máximo de colunas por linha é: 3\n",
            "\n",
            "Total de colunas é: 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# TUPLES\n",
        "\n",
        "Tuplas são como as listas, mas não é possível alterar os valores.\n",
        "\n",
        "  - Depois de definido não há como alterar pelo programa.\n",
        "  - Usamos parênteses \"()\" em vez de colchetes \"[ ]\"\n",
        "\n"
      ],
      "metadata": {
        "id": "05b0Z-SB2i08"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tuples\n",
        "tupla = (1, 2, 3, \"batata\")\n",
        "print(tupla)\n",
        "\n",
        "tupla = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)\n",
        "lista = [0]\n",
        "try:\n",
        "  tupla.append(lista[0])\n",
        "except: \n",
        "  lista.remove(0)\n",
        "  print(\"\\nNão podemos adicionar valores na tupla\")\n",
        "\n",
        "for i in tupla:\n",
        "  if i % 2 == 0:\n",
        "    lista.append(i)\n",
        "print(\"\\nOs números pares são:\" + str(lista))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5YKGfwhT29r4",
        "outputId": "768c97aa-c534-4c47-f169-e698c4b08372"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3, 'batata')\n",
            "\n",
            "Não podemos adicionar valores na tupla\n",
            "\n",
            "Os números pares são:[2, 4, 6, 8, 10, 12, 14]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dicionário\n",
        "\n",
        "São objetos que podemos colocar propriedades. São alteráveis ao longo do programa. \n",
        "\n",
        " - Podemos categorizar a partir de chaves de identificação.\n",
        " - Podemos remover e adicionar chaves \n",
        "\n",
        "---\n"
      ],
      "metadata": {
        "id": "Wo4U53w1wIxN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#--------------------------------------------------\n",
        "# Livros de uma biblioteca\n",
        "#--------------------------------------------------\n",
        "Livros = {\n",
        "    \"título\": \"Frankenstein\",\n",
        "    \"data\": \"1818\",\n",
        "    \"autor\": \"Mary Shelley\",\n",
        "    \"gênero\": \"Terror, Suspense, Clássico\"\n",
        "}\n",
        "# Imprime todos os livros no objeto\n",
        "print(Livros.items())\n",
        "\n",
        "# Imprime um item em específico do dicionário\n",
        "print(\"\\n\" + \"Título: \" + Livros.get(\"título\"))\n",
        "# Imprime as chaves das propriedades\n",
        "print(\"\\n\" + \"Chaves no dicionário: \" + str(Livros.keys()))\n",
        "# Imprime as chaves removidas\n",
        "print(\"\\n\" + \"Chaves removidas: \" + Livros.pop(\"gênero\"))\n",
        "# Imprime as chaves adicionadas\n",
        "Livros['descrição'] = \"Um universitário que fica obcecado em seus estudos.\"\n",
        "print(\"\\n\" + \"Descrição adicionada: \" + str(Livros))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iWw_kvsJwMOz",
        "outputId": "04fd06be-2d12-4336-cff6-a28292e27eca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dict_items([('título', 'Frankenstein'), ('data', '1818'), ('autor', 'Mary Shelley'), ('gênero', 'Terror, Suspense, Clássico')])\n",
            "\n",
            "Título: Frankenstein\n",
            "\n",
            "Chaves no dicionário: dict_keys(['título', 'data', 'autor', 'gênero'])\n",
            "\n",
            "Chaves removidas: Terror, Suspense, Clássico\n",
            "\n",
            "Descrição adicionada: {'título': 'Frankenstein', 'data': '1818', 'autor': 'Mary Shelley', 'descrição': 'Um universitário que fica obcecado em seus estudos.'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Try and Except Statements\n",
        "\n",
        "São blocos que tratam erros. \n",
        "  \n",
        "  - Pefeito para diagnosticar falhas e bugs.\n",
        "\n",
        "  - `try`: Tenta encontrar erros\n",
        "  - `except`: Informa se houve erro\n",
        "  - `finally`: Executa um código mesmo com erro\n",
        "  - `else`: Executa um código se não houver erro"
      ],
      "metadata": {
        "id": "2lH8t5qH4OmA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = \"oi\"\n",
        "try: \n",
        "  float(x)\n",
        "except:\n",
        "  print(\"Variável não pode ser convertida para float \\n\")\n",
        "else:\n",
        "  print(\"A variável tem o valor: \" + str(x))\n",
        "finally: \n",
        "  print(\"\\n Mude o valor da variável e teste sempre por erros.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P2P_4jIE5FIG",
        "outputId": "089accb8-6f60-4edf-c564-c2733701417b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Variável não pode ser convertida para float \n",
            "\n",
            "\n",
            " Mude o valor da variável e teste sempre por erros.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Classes e Constructors\n",
        "\n",
        "**Classes** (*objeto de construtores*) são blocos que seguem um modelo de dados (blueprint).\n",
        "\n",
        "**Construtores** por sua vez são métodos (*funções*) que são úteis \n",
        "\n",
        "quando queremos criar um objeto com atributos/properties (*variáveis*) definidas. \n",
        "\n",
        "  - Podemos categorizar e criar objetos (*instâncias*) \n",
        "  \n",
        "  - São informações personalizadas e organizadas ao instanciar\n",
        "\n",
        "  - Podemos criar heranças, isto é, colocar vários blocos de classes \n",
        "  \n",
        "  dentro de outras classes e organizar seus dados de forma mais categorizada.\n",
        "    - Atenção: Devemos usar o construtor __init__ só uma vez! \n",
        "\n",
        "    - que será na classe raíz (mãe).\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "Z9a__oH8-MBc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# -------------------------------------------------\n",
        "# Classe com Constructor de Inicialização\n",
        "# -------------------------------------------------\n",
        "class Compras:\n",
        "  # ----------------------------------------------\n",
        "  # Atributos (variáveis) no Método (função)\n",
        "  # ----------------------------------------------\n",
        "  def __init__(self, tipo, nome, preco):\n",
        "    self.tipo = tipo\n",
        "    self.nome = nome\n",
        "    self.preco = preco\n",
        "# -------------------------------------------------\n",
        "# Método Próprio\n",
        "# -------------------------------------------------\n",
        "  def cadastro(self):\n",
        "    print(self.nome)\n",
        "\n",
        "ComprasDoMes = Compras(\"Tubérculo\", \"Batata\", 2.99)\n",
        "\n",
        "print(ComprasDoMes.tipo)\n",
        "print(ComprasDoMes.nome)\n",
        "print(ComprasDoMes.preco)\n",
        "# -------------------------------------------------\n",
        "# Classe com métodos personalizados\n",
        "# -------------------------------------------------\n",
        "class Pessoa:\n",
        "  def __init__(meuobjeto_Parametro, name, age):\n",
        "    meuobjeto_Parametro.name = name\n",
        "    meuobjeto_Parametro.age = age\n",
        "\n",
        "  def minhafuncao(saudacao):\n",
        "    print(\"Olá, O meu nome é: \" + saudacao.name)\n",
        "\n",
        "p1 = Pessoa(\"Alfredo\", 42)\n",
        "p1.minhafuncao() "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gBTGDHXl-Kzl",
        "outputId": "a20e56a0-c501-48fe-c62b-b0bd93bdb73e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tubérculo\n",
            "Batata\n",
            "2.99\n",
            "Olá, O meu nome é: Alfredo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercícios\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "k_CIJiLs5O3l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#------------------------------------------------------------------------------\n",
        "# Verificação de valores em lista:\n",
        "#------------------------------------------------------------------------------\n",
        "myList = [-1, 11, 14, 75, 98, 46, 81, 36]\n",
        "#------------------------------------------------------------------------------\n",
        "# Verificação de valor máximo em lista:\n",
        "#------------------------------------------------------------------------------\n",
        "def TheMax(listed_Numbers):\n",
        "  max = listed_Numbers[0]\n",
        "  for i in listed_Numbers:\n",
        "    if i > max:\n",
        "      max = i;\n",
        "  return max\n",
        "#------------------------------------------------------------------------------\n",
        "# Resultado:\n",
        "#------------------------------------------------------------------------------\n",
        "print(\"O máximo é: \" + str(TheMax(myList)))\n",
        "\n",
        "#------------------------------------------------------------------------------\n",
        "# Verificação de valor mínimo em lista:\n",
        "#------------------------------------------------------------------------------\n",
        "def TheMin(listed_Numbers):\n",
        "  min = listed_Numbers[0]\n",
        "  for i in listed_Numbers:\n",
        "    if i < min:\n",
        "      min = i;\n",
        "  return min\n",
        "#------------------------------------------------------------------------------\n",
        "# Resultado:\n",
        "#------------------------------------------------------------------------------\n",
        "print(\"O mínimo é: \" + str(TheMin(myList)))\n",
        "\n",
        "#------------------------------------------------------------------------------\n",
        "# Soma de valores em lista:\n",
        "#------------------------------------------------------------------------------\n",
        "def TheSum(listed_Numbers):\n",
        "  sumAll = 0\n",
        "  for i in listed_Numbers:\n",
        "    sumAll += i # sumAll = sumAll + i\n",
        "  return sumAll\n",
        "#------------------------------------------------------------------------------\n",
        "# Resultado:\n",
        "#------------------------------------------------------------------------------\n",
        "# myList = [-1, 11, 14, 75, 98, 46, 81, 36]\n",
        "# myList = [1, 11, 14, 16, 33, 46, 75, 81, 98]\n",
        "print(\"A soma dos valores é: \" + str(TheSum(myList)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BCFXPE1cOwBb",
        "outputId": "2a0bef04-3618-4b28-c518-a02b2527fbc9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "O máximo é: 98\n",
            "O mínimo é: -1\n",
            "A soma dos valores é: 360\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#------------------------------------------------------------------------------\n",
        "# Equação de Segundo Grau\n",
        "# Exercício 9\n",
        "#------------------------------------------------------------------------------\n",
        "# De Acordo com a fórmula da equação de segundo grau abaixo. Faça uma função\n",
        "# que calcule e imprima os resultados de uma equação de segundo grau, Para que\n",
        "# seu código fique organizado, faça uma função extra que calcule o Delta ()\n",
        "# em separado, Utilize os seguinte valores como entrada: \n",
        "# a = 88 b = 4 c = 16\n",
        "\n",
        "#------------------------------------------------------------------------------\n",
        "# Resolução:\n",
        "#------------------------------------------------------------------------------\n",
        "import math\n",
        "import cmath\n",
        "#------------------------------------------------------------------------------\n",
        "# Primeiro importamos a biblioteca cmath do Python\n",
        "# Veja a documentação do cmath aqui: \n",
        "# https://docs.python.org/3/library/cmath.html\n",
        "#------------------------------------------------------------------------------\n",
        "# Cálculo\n",
        "#------------------------------------------------------------------------------\n",
        "def calc_delta(a, b, c):\n",
        "  return b ** 2 - (4 * a * c)\n",
        "\n",
        "def calc_bhaskara(a:float, b:float, c:float):\n",
        "  delta = calc_delta(a, b, c)\n",
        "  if delta == 0:\n",
        "    x1 = (-b + (delta ** 0.5)) / (2 * a)\n",
        "    return x1\n",
        "  else:\n",
        "    if delta > 0:\n",
        "      x1 = (-b - math.sqrt(delta)) / (2 * a)\n",
        "      x2 = (-b + math.sqrt(delta)) / (2 * a)  \n",
        "    else:\n",
        "      x1 = (-b - cmath.sqrt(delta)) / (2 * a)\n",
        "      x2 = (-b + cmath.sqrt(delta)) / (2 * a)\n",
        "    return [x1, x2]\n",
        "#------------------------------------------------------------------------------\n",
        "# Veja a confirmação da solução aqui:\n",
        "# https://coolconversion.com/math/quadratic-equation-calculator/\n",
        "#------------------------------------------------------------------------------\n",
        "# Resultado\n",
        "#------------------------------------------------------------------------------\n",
        "def bhaskara_answer(): \n",
        "  print(\"\\n A resposta é: \" + str(verify_input(a, b, c)))\n",
        "#------------------------------------------------------------------------------\n",
        "# Verificação de Inputs\n",
        "#------------------------------------------------------------------------------\n",
        "def verify_input(a, b, c):\n",
        "  #---------------------------------------------------------------------------\n",
        "  # Valores A, B e C em Lista\n",
        "  #---------------------------------------------------------------------------\n",
        "  values = [a, b, c]\n",
        "  #---------------------------------------------------------------------------\n",
        "  # Uso do WHILE para garantir que o loop não termine até o tempo certo.\n",
        "  #---------------------------------------------------------------------------\n",
        "  while not verify_loop(values):\n",
        "    a_recheck = A(a)\n",
        "    b_recheck = B(b)\n",
        "    c_recheck = C(c)\n",
        "    values = [a_recheck, b_recheck, c_recheck]\n",
        "  else:\n",
        "    print(\"\\n Ok, vamos calcular...\")\n",
        "  #---------------------------------------------------------------------------\n",
        "  # O uso do time aqui é opcional e é um detalhe mais estético neste caso. \n",
        "  # É apenas para mostrar um carregamento maior ao usuário.\n",
        "  #---------------------------------------------------------------------------\n",
        "    import time\n",
        "    time.sleep(5)\n",
        "    return calc_bhaskara(float(values[0]), float(values[1]), float(values[2]))\n",
        "#------------------------------------------------------------------------------\n",
        "# Recheck dos Valores A, B e C\n",
        "#------------------------------------------------------------------------------  \n",
        "def A(a):\n",
        "  return input(\"\\nInsira valor de a:\")\n",
        "def B(b):\n",
        "  return input(\"Insira valor de b:\")\n",
        "def C(c):\n",
        "  return input(\"Insira valor de c:\")\n",
        "#------------------------------------------------------------------------------\n",
        "# Verificação Iterada\n",
        "#------------------------------------------------------------------------------\n",
        "def verify_loop(values):\n",
        "  aprovado = True\n",
        "  #---------------------------------------------------------------------------\n",
        "  # Uso do FOR para validar cada um dos números da lista.\n",
        "  #---------------------------------------------------------------------------\n",
        "  for i in values:\n",
        "    try:\n",
        "        float(i)\n",
        "    except: #ValueError\n",
        "      validate = False\n",
        "    else:\n",
        "      validate = True\n",
        "  #---------------------------------------------------------------------------\n",
        "  # Verificação de Valores Incorretos\n",
        "  # Quer saber porquê usamos o \"not\" aqui? Veja alguns exemplos: \n",
        "  # https://www.geeksforgeeks.org/python-check-if-list-empty-not/\n",
        "  #---------------------------------------------------------------------------\n",
        "    if validate == False:\n",
        "      if not i:\n",
        "        print(\"\\n Insira um número, sem espaço vazio para o \" \n",
        "              + str(values.index(i) + 1) + \"° valor!\")\n",
        "      else:\n",
        "        print(\"\\n Insira um número correto para o \" \n",
        "              + str(values.index(i) + 1) + \"° valor!\")\n",
        "      aprovado = False\n",
        "    else:\n",
        "      if values.index(i) == 0 and i == \"0\":\n",
        "        print(\"\\n O número zero não é aceito no coeficiente 'A'!\")\n",
        "        aprovado = False\n",
        "  return aprovado\n",
        "#------------------------------------------------------------------------------\n",
        "# Input de Valores Iniciais\n",
        "#------------------------------------------------------------------------------  \n",
        "a = input(\"Insira o valor a:\")\n",
        "b = input(\"Insira o valor b:\")\n",
        "c = input(\"Insira o valor c:\")\n",
        "#------------------------------------------------------------------------------\n",
        "# Chamada do Resultado\n",
        "#------------------------------------------------------------------------------\n",
        "bhaskara_answer()\n",
        "#------------------------------------------------------------------------------"
      ],
      "metadata": {
        "id": "kWxAo1Ih5N4m",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6808062c-feee-41c8-94fa-58689a62ae89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Insira o valor a:1\n",
            "Insira o valor b:0\n",
            "Insira o valor c:0\n",
            "\n",
            " Ok, vamos calcular...\n",
            "\n",
            " A resposta é: 0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#------------------------------------------------------------------------------\n",
        "# Lógica de Programação e Conceitos\n",
        "# Exercício 12\n",
        "#------------------------------------------------------------------------------\n",
        "# 1) Para que serve os operadores lógicos?\n",
        "#\n",
        "# e) Fazer validações/operações entre dados \n",
        "# (com números, strings e booleanos, etc)\n",
        "#------------------------------------------------------------------------------\n",
        "# 2) O que o operador lógico \"not\" faz?\n",
        "#\n",
        "# d) Negar um booleano, alterando seu valor\n",
        "#------------------------------------------------------------------------------\n",
        "# 3)\n",
        "print(7 > 8 or 8 < 9)\n",
        "#------------------------------------------------------------------------------\n",
        "#------------------------------------------------------------------------------\n",
        "# 4) \n",
        "print(7 > 8 and 8 < 9)\n",
        "#------------------------------------------------------------------------------\n",
        "#------------------------------------------------------------------------------\n",
        "# 5) \n",
        "print(not (1 > 2))\n",
        "#------------------------------------------------------------------------------\n",
        "#------------------------------------------------------------------------------\n",
        "# 6)\n",
        "print(not (not(30 < 34) or (0 > 1)))\n",
        "#------------------------------------------------------------------------------\n",
        "#------------------------------------------------------------------------------"
      ],
      "metadata": {
        "id": "ZyCqu_cDpRnH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57c4346f-4fe6-449e-e6f9-c7bc948e5c9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "True\n"
          ]
        }
      ]
    }
  ]
}