Notebooks/draft/Aula_3_Loops_e_condicionais.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FGV - Escola de Matemática Aplicada\n",
    "==\n",
    "Curso de Verão - Introdução à Programação com a Linguagem Python\n",
    "--"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionais e Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=32\n",
    "def fun1(a=23):\n",
    "    global b\n",
    "    b=10\n",
    "    a += b\n",
    "    return b\n",
    "print(fun1(13))\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Condicionais:\n",
    "\n",
    "Em Python usamos os Controles de Fluxo if/elif/else para avaliar as condições que são postas na estrutura do código. As condições são sequencias que devem ser avaliadas em True ou False e uma estrutura condicional simples pode conter vários elif, mas somente um else."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Modelo da sintaxe:\n",
    "\n",
    "###### if condição1:\n",
    "\n",
    "   código a ser implementado caso a condição 1 seja verdadeira.\n",
    "    \n",
    "###### elif condição2:\n",
    "\n",
    "   código a ser implementado caso a condição 1 seja falsa e a condição 2 seja verdadeira.\n",
    "    \n",
    "###### elif condição3:\n",
    "\n",
    "   código a ser implementado caso as condições 1 e 2 sejam falsas e a condição 3 seja verdadeira.\n",
    "    \n",
    "###### else:\n",
    "\n",
    "   código a ser implementado caso nenhuma das condições acima sejam verdadeiras\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o nome começa com i e termina com U\n",
      "Saí do if\n"
     ]
    }
   ],
   "source": [
    "nome = 'Uerlei'\n",
    "\n",
    "if nome.startswith('T'):\n",
    "    print('o nome começa com {}'.format(nome[0]))\n",
    "    print('Estou aqui')\n",
    "elif nome.startswith('U'):\n",
    "    print('o nome começa com {1} e termina com {0}'.format(nome[0],nome[-1]))\n",
    "elif nome.startswith('V'):\n",
    "    print('o nome começa com {}'.format(nome[0]))\n",
    "elif nome.startswith('X'):\n",
    "    print('o nome começa com {}'.format(nome[0]))\n",
    "elif nome.startswith('Z'):\n",
    "    print('o nome começa com {}'.format(nome[0]))\n",
    "else:\n",
    "    print('o nome não começa com T,U,V, X ou Z')\n",
    "print('Saí do if')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar, também, condicionais aninhadas. Isto é, dentro do código a ser rodado caso alguma condição seja verdadeira podemos colocar outra estrutura if/elif/else. Vejamos no exemplo a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maior que 5\n"
     ]
    }
   ],
   "source": [
    "numero = 6\n",
    "if numero > 5:\n",
    "    print('maior que 5')\n",
    "    if numero > 7:\n",
    "        print('maior que 7')\n",
    "        if numero > 3:\n",
    "            print('maior que 3')\n",
    "else:\n",
    "    print('o numero é menor ou igual a 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range:\n",
    "\n",
    "Range representa uma sequência imutável de números e é usado para fazer um número específico de loop nos loops. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O resultado gerado é uma lista que vai de 0 até o número dado como argumento - 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(1,13)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0,11,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse caso temos o intervalo definido. Dessa forma, o resultado gerado é uma lista que vai do primeiro número dado até o segundo - 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "gen50 = range(5,51,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(5, 51, 3)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = list(gen50)\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Já nesse caso temos a estrutura composta por range(início do intervalo, fim do intervalo + 1, diferença entre um elemento e o próximo na sequência). Dessa forma temos que os elementos, no exemplo, são listados, de três em três, de 5 até 50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 282429536481)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(9**12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " #### O comando \"for\":\n",
    "\n",
    "Executa uma seqüência de instruções várias vezes, até que o intervalo dado termine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "Margaridas\n",
      "\n",
      "4\n",
      "Margaridas\n",
      "\n",
      "6\n",
      "Margaridas\n",
      "\n",
      "8\n",
      "Margaridas\n",
      "\n",
      "10\n",
      "Margaridas\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for inteiro in range(2,11,2):\n",
    "    print(inteiro)\n",
    "    #print()\n",
    "    #print(inteiro + 1)\n",
    "    print('Margaridas')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "\n",
      "9\n",
      "\n",
      "25\n",
      "\n",
      "49\n",
      "\n",
      "81\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for inteiro in range(1,10,2):\n",
    "    print(inteiro**2)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n",
      "e\n",
      "u\n",
      " \n",
      "n\n",
      "o\n",
      "m\n",
      "e\n",
      " \n",
      "n\n",
      "ã\n",
      "o\n",
      " \n",
      "é\n",
      " \n",
      "J\n",
      "o\n",
      "h\n",
      "n\n",
      "n\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "for letra in 'Meu nome não é Johnny':\n",
    "    print(letra)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1\n",
      "4 16 64\n",
      "8 64 512\n",
      "9 81 729\n",
      "10 100 1000\n"
     ]
    }
   ],
   "source": [
    "for elemento in [1,4,8,9,10]:\n",
    "    print(elemento, elemento**2, elemento**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x,y,z = (1,2,3) # Definindo mais de uma variável em uma linha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "c = {1,4,4,4,4,5}\n",
    "for elemento in c:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instruções de comando de loop\n",
    "\n",
    "Elas alteram a execução da sequência em sua ordem normal. São elas: break, continue e pass."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Break: \n",
    "Termina a instrução do loop e transfere a execução do loop para a próxima instrução."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of first  10 integers is :  55\n"
     ]
    }
   ],
   "source": [
    "numbers = range(1,1000)\n",
    "num_sum = 0  \n",
    "count = 0  \n",
    "for x in numbers:  \n",
    "    num_sum = num_sum + x  \n",
    "    count = count + 1   \n",
    "    if count == 10:  \n",
    "        break  \n",
    "print(\"Sum of first \",count,\"integers is : \", num_sum)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Continue:\n",
    "Continua com a próxima iteração do loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a latitude é 1\n",
      "a longitude é 2\n",
      "a latitude é 7\n",
      "a longitude é 9\n"
     ]
    }
   ],
   "source": [
    "for x,y in [(1,2),(3,6),(7,9)]:\n",
    "    if x == 3:\n",
    "        continue\n",
    "    print('a latitude é {}'.format(x))\n",
    "    print('a longitude é {}'.format(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found an even number 2\n",
      "Found an even number 4\n",
      "Found an even number 6\n",
      "Found an even number 8\n",
      "Found an even number 10\n"
     ]
    }
   ],
   "source": [
    "for num in range(2, 11):\n",
    "    if num % 2 == 0:\n",
    "        print(\"Found an even number\", num)\n",
    "    continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for numero in range(10):\n",
    "    if numero in [5,7,9]:\n",
    "        continue\n",
    "    print(numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pass:\n",
    "Pode ser usado quando uma declaração é requerida sintaticamente, mas o programa não requer nenhuma ação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def funcao1():\n",
    "    print('faz nada')\n",
    "\n",
    "def funcao2():\n",
    "    pass\n",
    "\n",
    "def funcao3():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Letter : P\n",
      "Current Letter : y\n",
      "Current Letter : t\n",
      "This is pass block\n",
      "Current Letter : h\n",
      "Current Letter : o\n",
      "Current Letter : n\n"
     ]
    }
   ],
   "source": [
    "for letter in 'Python': \n",
    "    if letter == 'h':\n",
    "        pass\n",
    "        print('This is pass block')\n",
    "    print('Current Letter :', letter)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Números ímpares divisíveis por 7 e 5 até 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[35]\n"
     ]
    }
   ],
   "source": [
    "seq = range(101)\n",
    "lista = []\n",
    "for numero in seq:\n",
    "    if numero%7 == 0 and numero%5 == 0 and numero%2 != 0:\n",
    "        lista.append(numero)\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Gerando números primos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48.63446784351075\n"
     ]
    }
   ],
   "source": [
    "print(time.time()/(3600*24*365))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.8021910190582275\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "primos = []\n",
    "for i in range(2, 10000):\n",
    "    k = True\n",
    "    for j in range(2, i):\n",
    "        if i%j==0:\n",
    "            k = False\n",
    "    if k:\n",
    "        primos.append(i)\n",
    "#print(primos)\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.09703826904296875\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "seq = range(3,10000)\n",
    "primos = [2]\n",
    "for candidato in seq:\n",
    "    E_primo = True\n",
    "    for primo in primos:\n",
    "        if candidato%primo == 0:\n",
    "            E_primo = False\n",
    "            break\n",
    "    if E_primo:\n",
    "        primos.append(candidato)\n",
    "        #print(candidato)\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### O comando \"while\":\n",
    "\n",
    "No comando WHILE declara-se uma condição de parada. Dessa maneira os comandos serão executados até que se chegue na condição de parada.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while x < 10:\n",
    "    print(x)\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n",
      "9\n",
      "6\n",
      "4\n",
      "10\n",
      "6\n",
      "5\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    print(random.randrange(1,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.05688533707124721\n",
      "0.6903354630207101\n",
      "0.7208417211782022\n",
      "0.5454929898193839\n",
      "0.5249891216439917\n",
      "0.7867142848018799\n",
      "0.5313115147421523\n",
      "0.7178881304983387\n",
      "0.8471452327029592\n",
      "0.13043034100633766\n",
      "0.9658097260676806\n",
      "0.6652434092869334\n",
      "0.9440230971477654\n",
      "0.47124377810570295\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    x = random.random()\n",
    "    print(x)\n",
    "    if 0.5 > x > 0.4:\n",
    "        break"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}