Operações_Matemáticas,Operações_Lógicas,Operações_Relacionais_e_Condicionais.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "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/metsumesquita/Python_resumo/blob/main/Opera%C3%A7%C3%B5es_Matem%C3%A1ticas%2COpera%C3%A7%C3%B5es_L%C3%B3gicas%2COpera%C3%A7%C3%B5es_Relacionais_e_Condicionais.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Operaçoes matematicas\n"
      ],
      "metadata": {
        "id": "LWyn_SX63LsD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#regras da matematicas continuam aqui\n",
        "#as operaçoes contento o parentese formam a serem feitas primeior\n",
        "#alem disso a ordem de prioridade que temos na matematicam permanence\n",
        "#logo  a exponenciaçao vem antes da multiplicaçao e da divissao\n",
        "#que vem antes da soma e da subtraçao\n",
        "#Outra regra Importante é que nao é permitido operaçoes entre strings"
      ],
      "metadata": {
        "id": "oZf88sF0q6Kh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Conversão de valores  numericos\n",
        "int(6.0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wyci6w1l6ysN",
        "outputId": "d3bf2f40-d55b-4653-cfe0-a072835cda44"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "float(9)"
      ],
      "metadata": {
        "id": "TDg78hemuhXC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#operaçoes matematicas a baixo\n",
        "soma=8+6\n",
        "print(soma)"
      ],
      "metadata": {
        "id": "grD4G-5M52_M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "float_soma=3.1 + 6.4\n",
        "print(\"soma entre valores to tipo float\"+float_soma)"
      ],
      "metadata": {
        "id": "ALaJRAlDvMpG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "subtraçao=8-2\n",
        "print(subtraçao)"
      ],
      "metadata": {
        "id": "SgBTyYss59Mt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#multiplicar\n",
        "b=2*3\n",
        "print(b)"
      ],
      "metadata": {
        "id": "4uw2ScZC3yVg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#outro exemplo da operação de multiplicação dentro de um outro contexto\n",
        "# da transfoormação da medida parsec para lightyears\n",
        "#onde 1 parsec vale 3.26 lightyears\n",
        "#nesse caso se há 11 parsecs quantos lightyears seriam ?\n",
        "parsec = 11\n",
        "num=3.26\n",
        "lightyears=parsec*num\n",
        "print(\"11 parsec is \"+str(lightyears)+\" lightyears\")"
      ],
      "metadata": {
        "id": "0i75ixr9plUi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#divisao\n",
        "c=10/2\n",
        "print(c)"
      ],
      "metadata": {
        "id": "uHiWmO4u30DO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#exponenciaçao\n",
        "a=2**5\n",
        "\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C37EbrQA3wkK",
        "outputId": "4ebb8e7c-fbeb-4da1-dc27-691a28538b6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "potencia=pow(3,2)# 3^2 = 9\n",
        "print(potencia)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "No5xwVg_4Mwu",
        "outputId": "b01bba08-9e3a-4343-d9fc-a4aea3d8431d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#aqui temos um exemplo de divisao inteira(QUOCIENTE)\n",
        "#o qual a variavel e retorna o valor do quociente que representa o número de vezes que o dividendo contém o divisor\n",
        "e=50//3\n",
        "print(e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "np95cqSz35CX",
        "outputId": "50324e28-b138-4aad-d4d2-33402a709aad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n",
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#aqui temos a variavel remainder fazendo a operaçao modulo que nos retorna o valor do Resto\n",
        "remainder=10%2\n",
        "print(remainder)\n",
        "#o resto em ingles é o remainder\n",
        "#pode ser bem util em alguns situaçoes"
      ],
      "metadata": {
        "id": "V5zlTpJP317P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#absolute difference python ou valor absoluto em python\n",
        "abs(80-100)"
      ],
      "metadata": {
        "id": "kn-UDAac8Rp1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#sqrt é utilizado para retornamos a raiz de um valor que foi passado como parametro\n",
        "\n",
        "import math\n",
        "#raiz\n",
        "print(math.sqrt(16))"
      ],
      "metadata": {
        "id": "_rnIoWGP6ag8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#arrendodamento  pra baixo ou pra cima\n",
        "\n",
        "arrendodado_cima=round(3.7)\n",
        "arredondado_baixo=round(3.2)\n",
        "print(arrendodado_cima)\n",
        "print(arredondado_baixo)"
      ],
      "metadata": {
        "id": "emv5Ubfe4RKe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#maximo e minimo entre valores\n",
        "\n",
        "maior_entre=max(4,6)#o maior entre os valores 4< 6 =6\n",
        "menor_entre=min(2,7)#o menor entre os dois valores 2<7 =2\n",
        "print(maior_entre)\n",
        "print(menor_entre)"
      ],
      "metadata": {
        "id": "cv3Yb_5S5seF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#vamos ver um pouco mais sobre operaçoes abaixo\n",
        "#aqui conseguimos ver uma acumulaçao do valor e depois outras operaçoes\n",
        "\n",
        "x=3\n",
        "#armazenamento\n",
        "\n",
        "y= x + 3\n",
        "print(\"o valor de y é:\"+str(y))#3+3=6\n",
        "\n",
        "# acumulamos o valor\n",
        "y+= 3\n",
        "print(\"o valor de y + 3 é igual a :\"+str(y))#6+3=9\n",
        "\n",
        "#retiramos um valor do valor anterior\n",
        "\n",
        "y-= 4\n",
        "print(\"o valor de y - 4 é igual a :\"+str(y))#9-4=5\n",
        "\n",
        "#fazemos uma nova operaçao(multiplicaçao) em cima do antigo valor\n",
        "\n",
        "y*=2\n",
        "print(\"o valor de y vezes 2 é igual a :\"+str(y))#5*2=10\n",
        "\n",
        "#temos aqui entao um exemplo de manipulaçao das variaveis x,y\n",
        "#alem da exibição das mudanças a cada operaçao ,com a transformaçao do valor inteiro em um string"
      ],
      "metadata": {
        "id": "SR3sKwQz8xwW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#este exemplo aqui é para ver se o primeiro valor é igual ao segundo valor passado\n",
        "0 == 0.0"
      ],
      "metadata": {
        "id": "Ir1qSC4v-8vG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "0=0.0\n",
        "#aqui nos encontramos um erro pelo uso inadequado da atribuiçao que é esse simbolo  ="
      ],
      "metadata": {
        "id": "pX57-2bT-u7U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#nesse problemas queremos saber quantos litros de agua vao ser carregadados por cada pessoa se\n",
        "#o caminhao com agua tem 320.5 litros de agua se temos 60 pessoas\n",
        "agua=320.5\n",
        "pessoas=60\n",
        "print(\"cada pessoa vai carregar a quantidade de \"+str(agua/pessoas)+\"de litros de agua\")\n",
        "#o float 320.5 esta sendo atribuido a variavel agua,isto é a variavel agua esta armazenando agora este valor que lhe foi passado\n",
        "#o mesmo acontece com a variavel pessoas que esta armazenando o valor 60 que é um dado do  tipo int"
      ],
      "metadata": {
        "id": "spUxMzha8tqk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "OPÇÃO normal"
      ],
      "metadata": {
        "id": "xfDqd-qkdZIH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "math.sqrt(2)"
      ],
      "metadata": {
        "id": "gsrrwApmdSkG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "math.sqrt(2)**2"
      ],
      "metadata": {
        "id": "ub8R0KWbdWx1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "math.sqrt(2)**2 == 2"
      ],
      "metadata": {
        "id": "wSXVk61vfQVl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "##compare com o que utiliza a biblioteca"
      ],
      "metadata": {
        "id": "VS1rQyfRfR6P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "math.sqrt(2)**2 - 2 < 1E-4"
      ],
      "metadata": {
        "id": "ndIV-0wJe3q3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "OPÇÃO UTILIZANDO A BIBLIOTECA SymPy"
      ],
      "metadata": {
        "id": "VjFNaLvce-rB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sympy"
      ],
      "metadata": {
        "id": "joGkvhuue-PH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.sqrt(2)"
      ],
      "metadata": {
        "id": "R_ZUE7RufD1_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 39
        },
        "outputId": "c13d1c4a-f6ff-422e-c71d-5dcbffb731be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "sqrt(2)"
            ],
            "text/latex": "$\\displaystyle \\sqrt{2}$"
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.sqrt(2)**2"
      ],
      "metadata": {
        "id": "CEhxdY7FfHyZ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "outputId": "40895143-1da4-42b0-fb7c-7e52724fe71e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ],
            "text/latex": "$\\displaystyle 2$"
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.sqrt(2)**2 == 2"
      ],
      "metadata": {
        "id": "KOi1GeQXfKgY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2865f69f-a033-4edb-d8bf-c78206c56043"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.sqrt(8)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 39
        },
        "id": "4eRChe33xso6",
        "outputId": "a24c98ae-9f13-45a1-e940-d38444c3de2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2*sqrt(2)"
            ],
            "text/latex": "$\\displaystyle 2 \\sqrt{2}$"
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.sympify('1/7')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "id": "eq2bY6Wl6d3o",
        "outputId": "bb5de434-d62b-43bf-b24d-3cc9a929cf7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1/7"
            ],
            "text/latex": "$\\displaystyle \\frac{1}{7}$"
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.Rational(1, 7)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "id": "euKOgX_r6kP5",
        "outputId": "ab3a792d-a562-4ced-fa36-fee0eb7e8167"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1/7"
            ],
            "text/latex": "$\\displaystyle \\frac{1}{7}$"
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.Rational(1, 2) + sympy.S('1/3')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "id": "Pscgd7Y06oDR",
        "outputId": "37aeaef5-0fd6-40b4-de72-bb49e139c3b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5/6"
            ],
            "text/latex": "$\\displaystyle \\frac{5}{6}$"
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.N(sympy.pi)"
      ],
      "metadata": {
        "id": "JNm12Bm1D_VX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sympy.oo"
      ],
      "metadata": {
        "id": "LVWsQ6ksD08o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#não é possivel fazer operação entre tipos diferentes"
      ],
      "metadata": {
        "id": "8DtYYSwtr0db"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"1\"+2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "id": "lkh6mwrGrkSG",
        "outputId": "2de38860-d8ac-4e80-ae59-6f8b7f07aa79"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "can only concatenate str (not \"int\") to str",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-5c53161196cd>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"1\"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Resolvendo uma equação do 2 grau"
      ],
      "metadata": {
        "id": "kWuHGaqmuzHt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Escreva um programa que resolva uma equação de segundo grau.\n",
        "#nao sabemos o valor de x nem de delta\n",
        "#aqui temos o input para receber os dados\n",
        "#ou seja uma entrada de dados\n",
        "#depois temos o int para transforma esses dados do tipo str  em int\n",
        "A=int(input(\"Digite um numero inteiro  Para A: \"))\n",
        "B=int(input(\"Digite um numero inteiro  Para B: \"))\n",
        "C=int(input(\"Digite um numero inteiro  Para C: \"))\n",
        "delta=(B*B) - (4*A*C)\n",
        "print(delta)\n",
        "x1=-(B-delta)/(2*A)\n",
        "x2=-(B+delta)/(2*A)\n",
        "print(\"o valor de   x1 é \"+str(x1)+\" o valor de x2 é \"+str(x2))"
      ],
      "metadata": {
        "id": "qdClXcba8qMt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Utilizaçao de def para fazer operaçoes matematicas"
      ],
      "metadata": {
        "id": "7vqM_XKMBycg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#FUNÇOES MATEMATICAS\n",
        "#Esta função somar dois números\n",
        "def soma(x, y):\n",
        " return x + y\n",
        "#Esta função subtrai dois números\n",
        "def subi(x, y):\n",
        " return x - y\n",
        "#Esta função multiplica dois números\n",
        "def multipl(x, y):\n",
        " return x * y\n",
        "#Esta função divide dois números\n",
        "def divid(x, y):\n",
        " return x / y\n",
        "#\n",
        "def quociente(x,y):\n",
        "  return x//y\n",
        "#\n",
        "def modulo(x,y):\n",
        " return x%y\n",
        "print(\"Esclha a Operação.\")\n",
        "print(\"1.sum\")\n",
        "print(\"2.sub\")\n",
        "print(\"3.multiple\")\n",
        "print(\"4.divide\")\n",
        "print(\"5.divisao inteira(QUOCIENTE)\")\n",
        "print(\"6.Resto == Modulo\")\n",
        "\n",
        "choice = input(\"Escolha(1/2/3/4):\")\n",
        "num1 = int(input(\"Informe o primeiro numero: \"))\n",
        "num2 = int(input(\"Informe o segundo numero: \"))\n",
        "if choice == '1':\n",
        " print(num1,\"+\",num2,\"=\", soma(num1,num2))\n",
        "elif choice == '2':\n",
        " print(num1,\"-\",num2,\"=\", subi(num1,num2))\n",
        "elif choice == '3':\n",
        " print(num1,\"*\",num2,\"=\",multipl(num1,num2))\n",
        "elif choice == '4':\n",
        " print(num1,\"/\",num2,\"=\", divid(num1,num2))\n",
        "elif choice == '5':\n",
        " print(num1,\"//\",num2,\"=\", quociente(num1,num2))\n",
        "elif choice == '5':\n",
        " print(num1,\"//\",num2,\"%\", modulo(num1,num2))\n",
        "else:\n",
        " print(\"Entrada Invalida\")"
      ],
      "metadata": {
        "id": "utxypoZw9Hyz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Utilizaçao do Format com valores numericos"
      ],
      "metadata": {
        "id": "I8c2gtFTu-HZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#alem disso podemos print dessa outra forma as seguintes operaçoes\n",
        "\n",
        "value_1=int(input(\"Digite um numero inteiro : \"))\n",
        "value_2=int(input(\"Digite outro numero inteiro: \"))\n",
        "\n",
        "somar= value_1 + value_2\n",
        "\n",
        "subtrair = value_1 - value_2\n",
        "\n",
        "dividir=value_1/value_2\n",
        "multiplicar=value_1*value_2\n",
        "\n",
        "resto=value_1%value_2\n",
        "print('Soma: {}  Subtraçao: {}  divisao: {}  multiplicaçao: {};'.format(somar,subtrair,dividir,multiplicar))\n",
        "#aqui utilizamos o format que sera posteiormente visto mais  aprofundamente"
      ],
      "metadata": {
        "id": "KeFBfUZZ82Qk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "result=100/777\n",
        "print(\"o resultado é {r:1.4f}\".format(r=result))\n",
        "#esse esse .4 quer dizer que sao 4 casas decimais"
      ],
      "metadata": {
        "id": "EYWP6Y5AuGZm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Operador logico e relacional\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "#####Operador relacional\n",
        "######== se iquais\n",
        "######!= se diferentes\n",
        "######<  menor,> maior ,<=  menor iqual,>= maior iqual\n",
        "---\n",
        "Operador logico\n",
        "\n",
        "o operador OR espera que pelo menos uma das condiçoes seja verdadeira\n",
        "\n",
        "o operador AND espera que as duas das condiçoes sejam verdadeiras\n",
        "\n",
        "o operador NOT inverte o valor/resultado\n",
        "\n"
      ],
      "metadata": {
        "id": "UlkPRCR9wm2u"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##OPERAÇÃO AND"
      ],
      "metadata": {
        "id": "1J8dZYfcip7G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A=5\n",
        "B=15\n",
        "C=20\n",
        "\n",
        "\n",
        "print(\"A<B and B<C :\",A<B and B<C)\n",
        "\n",
        "print(\"\\nA>B and B<C :\",A>B and B<C)\n",
        "\n",
        "print(\"\\nA<B and B>C :\",A<B and B>C)\n",
        "\n",
        "\n",
        "print(\"\\nA>B and B>C :\",A>B and B>C)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "46RXgTJegQQ2",
        "outputId": "b4233533-c893-437c-824e-47f6216d7079"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A<B and B<C : True\n",
            "\n",
            "A>B and B<C : False\n",
            "\n",
            "A<B and B>C : False\n",
            "\n",
            "A>B and B>C : False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# AND\n",
        "var1=4\n",
        "var2=3\n",
        "var3=6\n",
        "soma=var1+var3 #10   10>7 10>9\n",
        "soma2=var1+var2#7    7<10 7<9\n",
        "soma3=var2+var3#9    9>7 9<10\n",
        "print(soma>soma2 and soma>soma3) #ambas afirmaçoes sao verdadeiras\n",
        "print(soma<soma2 and soma>soma3) #ambas afirmaçoes nao sao verdadeiras ,a primeira condiçao é falsa"
      ],
      "metadata": {
        "id": "iXqTfGqowtdV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##OPERAÇÃO OR"
      ],
      "metadata": {
        "id": "SjehvdVvgPJw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#OR\n",
        "print(soma>soma2 or soma>soma3) #ambas afirmaçoes sao verdadeiras,o or retorna  TRUE que pelo menos 1 seja verdadeira\n",
        "print(soma<soma2 or soma>soma3) #ambas afirmaçoes nao sao verdadeiras,mas o or retorna true com uma condiçao verdadeira"
      ],
      "metadata": {
        "id": "uxT3q2VY0LXI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A=5\n",
        "B=15\n",
        "C=20\n",
        "\n",
        "\n",
        "print(\"A<B or B<C :\",A<B or B<C)\n",
        "\n",
        "print(\"\\nA>B or B<C :\",A>B or B<C)\n",
        "\n",
        "print(\"\\nA<B or B>C :\",A<B or B>C)\n",
        "\n",
        "\n",
        "print(\"\\nA>B or B>C :\",A>B or B>C)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EgDmub1sgP3t",
        "outputId": "ab75337f-d40e-417e-d68b-28501597d9c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A<B or B<C : True\n",
            "\n",
            "A>B or B<C : True\n",
            "\n",
            "A<B or B>C : True\n",
            "\n",
            "A>B or B>C : False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Condicional\n",
        "\n",
        "---\n",
        "\n",
        "```\n",
        "# if condiçao :\n",
        "   print(algo)\n",
        "```\n",
        "nesse codigo acima\n",
        "  um tab ou 4 espaços entao  linha/ou bloco que acontece se cumprir a condiçao\n",
        "  a tecla TAB fica mais a esquerda do teclado proxima do \" ' e do Q"
      ],
      "metadata": {
        "id": "d2Ge9DG20aqa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#if e elif\n",
        "five=5\n",
        "if five<10:\n",
        "  print('smaller')\n",
        "elif five>20:\n",
        "  print('bigger');"
      ],
      "metadata": {
        "id": "XHFDYwO00eEG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "temperatura=25\n",
        "if temperatura>35:\n",
        "    print(\"é um dia escandalte\")\n",
        "elif temperatura>=30:\n",
        "  print(\"é um dia comum\")\n",
        "elif temperatura>20:\n",
        "  print(\"é um dia ameno\")\n",
        "elif temperatura>10:\n",
        "  print(\"é um dia congelante\")\n",
        "else:\n",
        "  print(\"é um dia severo\")\n",
        "##aqui temos o fim de um bloco\n",
        "print('done')"
      ],
      "metadata": {
        "id": "E7ufhnWA1qVV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#vamos para outro exemplo que vamos ver como a indentaçao é importante\n",
        "#var1=4  var3=6\n",
        "##precisa executar alguns celulas acima pra poder ter o valor ve var1 e var3\n",
        "if var3>var1:                                                                   #linha 1\n",
        "  if var3>0:                                                                    #linha 2 aqui temos um tab em relaçao ao 1 if\n",
        "    print(\"a variavel var3 é positiva e ela é maior do que a variavel var1\")    #liha  3 aqui temos 2 tabs em relaçao ao 1 if\n",
        "  else:                                                                         #linha 4 aqui temos 2 tabs, esta alinhado com relaçao ao segundo if\n",
        "    print(\"a variavel var3 nao é positiva e nao é maior do que a variavel var1\")#linha 5 aqui temos 2 tabs\n",
        "else:                                                                           #linha 6\n",
        "  print(\"a variavel var 3 é menor que a variavel var1\")                         #linha 7 aqui temos um tab e esta alinhado ao primeiro if"
      ],
      "metadata": {
        "id": "NAZ1arct1u84"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Problema de transformaço de medidas de peso"
      ],
      "metadata": {
        "id": "tbbc2rKH2FPV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Weight=input('informe o peso : ')\n",
        "unit=input('utilizar grams (K)g ou pounds (L)bs:')\n",
        "if unit.upper()==\"L\":\n",
        "  form=int(Weight)*0.45\n",
        "  print(\"o valor em Kg é\"+str(form))\n",
        "elif unit.upper()==\"K\":\n",
        "  form=int(Weight)/0.45\n",
        "  print(\"o valor em Lbs/pounds é :\"+str(form))\n",
        "else:\n",
        "  print(\"esta errada o tipo da medida escolhida\")"
      ],
      "metadata": {
        "id": "8XmuJdSY2EBT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##resolvendo se o aluno foi ou nao aprovado por media (utiliza condicional)"
      ],
      "metadata": {
        "id": "i69jzywtvqil"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Faça um programa que receba duas notas digitadas pelo usuário.\n",
        "# Se a nota for maior ou igual a seis, escreva aprovado, senão escreva reprovado.\n",
        "QG_1=int(input(\"Informe a primeira atividade avaliativa do aluno/a\"))\n",
        "QG_2=int(input(\"Informe a segunda atividade avaliativa do aluno/a\"))\n",
        "if((QG_1>10 or QG_1<0) or (QG_2>10 or QG_2<0)):\n",
        "  print(\"valor inadequado\")\n",
        "else:\n",
        "  media= (QG_1+QG_2)/2\n",
        "  if(media>=6):\n",
        "    print(\"aluno aprovado \")\n",
        "  else:\n",
        "    print(\"aluno reprovador\")"
      ],
      "metadata": {
        "id": "4Ux7ATRovx1r"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}