cap2-intro_python-controle_de_fluxo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução ao Python - Capítulo 2 - Controle de Fluxo\n",
    "\n",
    "---\n",
    "<br>\n",
    "\n",
    "**Índice**<a id='indice'></a><br>\n",
    "1 - [Declarações condicionais](#1)<br>\n",
    "2 - [Expressões booleanas para condições](#2)<br>\n",
    "3 - [Loops for](#3)<br>\n",
    "4 - [Criando dicionários](#4)<br>\n",
    "5 - [Loops while](#5)<br>\n",
    "6 - [Pausa e continuação](#6)<br>\n",
    "7 - [Zip e enumeração](#7)<br>\n",
    "8 - [Compreensão de listas](#8)<br>\n",
    "<br>\n",
    " \n",
    "### 1. Declarações condicionais<a id='1'></a>\n",
    "---\n",
    "#### 1.1. Declaração if\n",
    "Uma declaração `if` é uma declaração condicional que é executada ou ignora o código dependendo de uma condição ser verdadeira ou falsa. Aqui está um exemplo simples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "phone_balance = 5\n",
    "if phone_balance < 5:\n",
    "    phone_balance += 10\n",
    "    bank_balance -= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos entender isso.\n",
    "1. Uma declaração `if` começa com a palavra-chave `if`, seguido pela condição a ser verificada, nesse caso `phone_balance < 5` e, depois, dois pontos. A condição é especificada em uma expressão booleana que é avaliada como true ou false.\n",
    "2. Após esta linha, está um bloco de código recuado (indentado) a ser executado se a condição for verdadeira. Aqui, as linhas que acrescem `phone_balance` e `decrescem bank_balance` só serão executadas se for verdade que `phone_balance` é menor que 5. Caso contrário, o código neste bloco `if` é simplesmente ignorado.\n",
    "\n",
    "#### 1.2. if, elif, else\n",
    "Além da cláusula `if`, existem duas outras cláusulas opcionais geralmente usadas com uma declaração `if`. Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unrecognized season\n"
     ]
    }
   ],
   "source": [
    "season = 'alegria'\n",
    "if season == 'spring':\n",
    "    print('plant the garden!')\n",
    "elif season == 'summer':\n",
    "    print('water the garden!')\n",
    "elif season == 'fall':\n",
    "    print('harvest the garden!')\n",
    "elif season == 'winter':\n",
    "    print('stay indoors!')\n",
    "else:\n",
    "    print('unrecognized season')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `if`: Uma declaração `if` deve sempre começar com uma cláusula `if`, que contém a primeira condição que é verificada. Se ela for avaliada como true, o Python executa o código indentado neste bloco `if` e, então, pula para o resto do código depois da declaração `if`.\n",
    "2. `elif`: Uma cláusula `elif` é usada para verificar uma condição adicional, caso as condições nas cláusulas anteriores da declaração `if` forem avaliadas como `false`. Como você pode ver no exemplo, é possível ter vários blocos `elif` para lidar com situações diferentes.\n",
    "3. `else`: Por último, temos a cláusula `else`, que deve vir no final de uma declaração `if`, se for usada. Essa cláusula não exige uma condição. O código em um bloco `else` é executado se todas as condições acima dela na declaração `if` forem avaliadas como false.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3. Indentação\n",
    "Algumas outras linguagens utilizam chaves para mostrar onde os blocos de código começam e terminam. Em Python, nós usamos a indentação para delimitar os blocos de código. Por exemplo, declarações `if` usam indentação para informar ao Python qual código está dentro e fora das diferentes cláusulas.\n",
    "\n",
    "Em Python, a indentação convencionalmente vem em múltiplos de quatro espaços. Seja rigoroso quanto a seguir essa convenção, pois alterar a indentação pode mudar completamente o significado do código. Se você estiver trabalhando com uma equipe de programadores Python, é importante que todo mundo siga a mesma convenção de recuo!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Expressões booleanas para condições<a id='2'></a>\n",
    "---\n",
    "#### 2.1. Expressões booleanas complexas\n",
    "Declarações `if`, às vezes, usam expressões booleanas mais complicadas como suas condições. Elas podem conter vários operadores de comparação, operadores lógicos e até cálculos. Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is there a rainbow?\n",
      "send email\n"
     ]
    }
   ],
   "source": [
    "weight = 100\n",
    "height = 2\n",
    "if 18.5 <= weight / height**2 < 25:\n",
    "    print(\"BMI is considered 'normal'\")\n",
    "\n",
    "is_raining = True\n",
    "is_sunny = True\n",
    "if is_raining and is_sunny:\n",
    "    print(\"Is there a rainbow?\")\n",
    "\n",
    "unsubscribed = False\n",
    "location = 'CAN'\n",
    "if (not unsubscribed) and (location == \"USA\" or location == \"CAN\"):\n",
    "    print(\"send email\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para condições realmente complicadas, você pode precisar combinar alguns `and`, `or` e `not`. Use parênteses se precisar esclarecer as combinações.\n",
    "\n",
    "No entanto, simples ou complexa, a condição em uma declaração `if` deve ser uma expressão booleana que é avaliada como true ou false, e é esse valor que decide se o bloco indentado em uma declaração `if` é executado ou não."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2. Teste de valor verdade\n",
    "Se usarmos um objeto não booleano como uma condição em uma declaração `if` em vez da expressão booleana, o Python vai verificar seu valor verdade e usar isso para decidir se deve ou não executar o código indentado. Por padrão, o valor verdade de um objeto em Python é considerado verdadeiro, a menos que seja especificado como false na documentação.\n",
    "\n",
    "Aqui estão a maioria dos objetos internos que são considerados false em Python:\n",
    "\n",
    "- constantes definidas como false: `None` e `False`\n",
    "- zero de qualquer tipo numérico: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`\n",
    "- sequências e coleções vazias: `''`, `\"\"`, `()`, `[]`, `{}`, `set()`, `range(0)`\n",
    "\n",
    "Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have 3 errors to fix!\n"
     ]
    }
   ],
   "source": [
    "errors = 3\n",
    "if errors:\n",
    "    print(\"You have {} errors to fix!\".format(errors))\n",
    "else:\n",
    "    print(\"No errors to fix!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse código, os erros têm o valor verdade true porque é um número diferente de zero, então, a mensagem de erro é exibida. Essa é uma maneira boa e sucinta de escrever uma declaração `if`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Loops for<a id='3'></a>\n",
    "---\n",
    "O Python tem dois tipos de loops - loops `for` e loops `while`. Um loop `for` é utilizado para iterar um **iterável**.\n",
    "\n",
    "Um **iterável** é um objeto que pode retornar um de seus elementos de cada vez. Isso pode incluir tipos de sequência, como strings, listas e tuplas, bem como os tipos não sequenciais, como dicionários e arquivos. Você também pode definir iteráveis com [iteradores e geradores](https://anandology.com/python-practice-book/iterators.html), sobre os quais você vai aprender mais adiante.\n",
    "\n",
    "Vamos analisar os componentes de um loop `for`. Segue um exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New York City\n",
      "Mountain View\n",
      "Chicago\n",
      "Los Angeles\n"
     ]
    }
   ],
   "source": [
    "# iterável de cidades\n",
    "cities = ['new york city', 'mountain view', 'curitiba', 'chicago', 'los angeles']\n",
    "\n",
    "# loop for que realiza uma iteração sobre a lista cities (cidades)\n",
    "for city in cities:\n",
    "    if city == 'curitiba':\n",
    "        continue\n",
    "    print(city.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1. Componentes de um loop for\n",
    "1. A primeira linha do loop começa com a palavra-chave `for`, que sinaliza que se trata de um loop `for`\n",
    "2. Depois disso, vem `iteration_variable in iterable`, que indica que o iterável está passando por um ciclo de processamento (loop) e qual nome usar para o elemento do iterável que está sendo atualmente processado. Neste exemplo, a variável de iteração, `city`, seria “new york city” na primeira iteração e \"mountain view\" na segunda.\n",
    "3. A abertura de um loop `for` sempre termina com dois pontos `:`.\n",
    "4. Após a abertura de um loop `for` vem um bloco de código indentado que deve ser executado a cada iteração do loop `for`. Neste bloco, podemos usar a variável de iteração para acessar o valor do elemento que está sendo atualmente processado.\n",
    "\n",
    "Você pode nomear variáveis de iteração do jeito que preferir. Um padrão comum é dar à variável de iteração e ao iterável o mesmo nome, com exceção das versões singulares e plurais, respectivamente (por exemplo, 'cidade' e 'cidades').\n",
    "\n",
    "#### 3.2. Criando e alterando listas\n",
    "Além de extrair informações de listas, você também pode criar e modificar listas com loops `for`. Você pode criar uma ao acrescentar (com append) a uma nova lista a cada iteração do loop `for`, assim."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New York City\n",
      "Mountain View\n",
      "Chicago\n",
      "Los Angeles\n"
     ]
    }
   ],
   "source": [
    "# Criando uma nova lista\n",
    "cities = ['new york city', 'mountain view', 'chicago', 'los angeles']\n",
    "capitalized_cities = []\n",
    "\n",
    "for city in cities:\n",
    "    capitalized_cities.append(city.title())\n",
    "\n",
    "for city in capitalized_cities:\n",
    "    print(city)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alterar uma lista é um pouco mais complicado e requer o uso de uma nova função: `range()`.\n",
    "\n",
    "`range()` é uma função interna usada para criar sequências imutáveis de números. Ela tem três argumentos, que devem ser números inteiros.\n",
    "\n",
    "#### 3.3. `range(start=0, stop, step=1)`\n",
    "`tart` é o primeiro número da sequência, `stop` é 1 a mais do que o último número da sequência e `step` é a diferença entre cada número na sequência. Se não for especificado, o `start` padrão é 0, e o passo padrão é 1 (que é o que `= 0` e `= 1` nos diz acima).\n",
    "- Se você especificar um número inteiro dentro do parênteses com `range()`, ele é usado como o valor para 'stop', e os padrões são usados para os outros dois.\n",
    "    E.g. `list(range(4))` returns `[0, 1, 2, 3]`\n",
    "- Se você especificar dois números inteiros dentro do parênteses com `range()`, eles serão usados como o valor para `start` e `stop`, e o padrão será utilizado para `step`.\n",
    "    E.g. `list(range(2, 6))` returns `[2, 3, 4, 5]`\n",
    "- Ou você pode especificar todos os três inteiros para `start`, `stop` e `step`.\n",
    "    E.g. `list(range(1, 10, 2))` returns `[1, 3, 5, 7, 9]`\n",
    "\n",
    "Observe que, nesses exemplos, envolvemos `range` em uma lista. Isso ocorre porque a saída de `rang`e em si é apenas um objeto `range`. Podemos ver o conjunto de valores no objeto `range` ao convertê-lo em uma lista ou iterar por meio dele em um loop `for`.\n",
    "\n",
    "Nós podemos usar a função `range` para gerar os índices para cada valor na lista `cities`. Isso nos permite acessar os elementos da lista usando `cities[índice]`, para podermos alterar os valores em cada posição da lista `cities`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "cities = ['new york city', 'mountain view', 'chicago', 'los angeles']\n",
    "\n",
    "for index in range(len(cities)):\n",
    "    cities[index] = cities[index].title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enquanto alteração de lista é uma aplicação da função `range`, essa não é a única coisa útil. Você frequentemente usará `range` com um loop `for` para repetir uma ação um certo número de vezes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "Hello!\n",
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Criando dicionários<a id='4'></a>\n",
    "---\n",
    "Você já está familiarizado com dois importantes conceitos: 1) contagem usando loops for e 2) o método `get` dos dicionários. Na verdade, ambos os conceitos podem ser combinados para criar um contradicionário bastante útil, algo com o qual é provável que você se depare novamente. Por exemplo, podemos criar um dicionário, `word_counter`, que controla o número total de cada palavra em uma string.\n",
    "\n",
    "#### 4.1. Método 1: Usando um loop `for` para criar um conjunto de contadores\n",
    "Vamos começar com uma lista contendo as palavras de uma série de títulos de livros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "book_title =  ['great', 'expectations','the', 'adventures', 'of', 'sherlock','holmes','the','great','gasby','hamlet','adventures','of','huckleberry','fin']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Etapa 1:** Crie um novo dicionário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counter = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Etapa 2**: Itere por meio de cada elemento da lista. Se um elemento já estiver incluído no dicionário, adicione 1 ao seu valor. Caso contrário, adicione o elemento ao dicionário e defina seu valor como 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "for word in book_title:\n",
    "    if word not in word_counter:\n",
    "        word_counter[word] = 1\n",
    "    else:\n",
    "        word_counter[word] += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que está acontecendo aqui?\n",
    "- O loop `for` itera por meio de cada elemento da lista. Para a primeira iteração, `word` usa o valor `great`.\n",
    "- Depois disso, a declaração `if` verifica se `word` está no dicionário `word_counter`.\n",
    "- Como ainda não está, a declaração `word_counter[word] = 1` adiciona great ao dicionário como uma chave, com um valor de 1.\n",
    "- Em seguida, ela deixa a declaração else e segue para a iteração seguinte do loop for. Agora, `word` usa o valor expectations e repete o processo.\n",
    "- Quando a condição if não for cumprida, é porque essa `word` já existe no dicionário `word_counter` e a declaração `word_counter[word] = word_counter[word] + 1 aumenta o número daquela palavra em 1`.\n",
    "- Uma vez que o loop for termina de iterar a lista, ele está completo.\n",
    "\n",
    "Podemos visualizar o output imprimindo o dicionário. Imprimir `word_counter` tem como resultado o seguinte output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'great': 2, 'expectations': 1, 'the': 2, 'adventures': 2, 'of': 2, 'sherlock': 1, 'holmes': 1, 'gasby': 1, 'hamlet': 1, 'huckleberry': 1, 'fin': 1}\n"
     ]
    }
   ],
   "source": [
    "print(word_counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sinta-se à vontade para experimentar fazer você mesmo no editor de código localizado no rodapé desta página."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2. Método 2: Usando o método get\n",
    "Vamos usar a mesma lista para este exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "book_title =  ['great', 'expectations','the', 'adventures', 'of', 'sherlock','holmes','the','great','gasby','hamlet','adventures','of','huckleberry','fin']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Etapa 1:** Crie um novo dicionário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counter = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Etapa 2: Itere cada elemento, use o `get()` para obter o valor no dicionário e adicione 1.**\n",
    "\n",
    "Lembre que o método `get` para dicionários é uma outra maneira de recuperar o valor de uma chave em um dicionário. Mas, ao contrário da indexação, ele vai retornar um valor padrão se a chave não for encontrada. Se não for especificado, esse valor padrão é definido como None (nenhum). Podemos usar `get` com um valor padrão de 0 para simplificar o código do primeiro método acima."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "for word in book_title:\n",
    "    word_counter[word] = word_counter.get(word, 0) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que está acontecendo aqui?\n",
    "- O loop `for` itera a lista, conforme vimos anteriormente. O loop for alimenta a declaração seguinte no corpo do loop for com `great`.\n",
    "- Nets linha: `word_counter[word] = word_counter.get(word,0) + 1`, uma vez que a chave `great` ainda não existe no dicionário, `get()` vai retornar o valor 0 e `word_counter[word]` será definido como 1.\n",
    "\n",
    "- Ao encontrar uma palavra que já existe em `word_counter` (ex: a segunda ocorrência de '_the_'), o valor dessa chave é aumentado em 1. Na segunda ocorrência de 'the', o valor da chave adicionaria 1 novamente, tendo 2 como resultado.\n",
    "- Uma vez que o loop for termina de iterar a lista, ele está completo.\n",
    "\n",
    "Podemos visualizar o output imprimindo o dicionário. Imprimir `word_counter` tem como resultado o seguinte output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'great': 2, 'expectations': 1, 'the': 2, 'adventures': 2, 'of': 2, 'sherlock': 1, 'holmes': 1, 'gasby': 1, 'hamlet': 1, 'huckleberry': 1, 'fin': 1}\n"
     ]
    }
   ],
   "source": [
    "print(word_counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3. Iterando dicionários com loops for\n",
    "Quando você iterar um dicionário usando um loop for, fazer do jeito normal `(for n in some_dict)` vai apenas dar acesso às chaves do dicionário - que é o que queremos em algumas situações. Em outros casos, queremos iterar as _chaves_e_valores_ do dicionário. Vamos ver como isso é feito a partir de um exemplo. Considere este dicionário que usa nomes de atores como chaves e seus personagens como valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "cast = {\n",
    "           \"Jerry Seinfeld\": \"Jerry Seinfeld\",\n",
    "           \"Julia Louis-Dreyfus\": \"Elaine Benes\",\n",
    "           \"Jason Alexander\": \"George Costanza\",\n",
    "           \"Michael Richards\": \"Cosmo Kramer\"\n",
    "       }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterá-lo da forma usual com um loop for nos daria apenas as chaves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jerry Seinfeld\n",
      "Julia Louis-Dreyfus\n",
      "Jason Alexander\n",
      "Michael Richards\n"
     ]
    }
   ],
   "source": [
    "for key in cast:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quiser iterar tanto as chaves como os valores, você pode usar o método interno items desta forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actor: Jerry Seinfeld    Role: Jerry Seinfeld\n",
      "Actor: Julia Louis-Dreyfus    Role: Elaine Benes\n",
      "Actor: Jason Alexander    Role: George Costanza\n",
      "Actor: Michael Richards    Role: Cosmo Kramer\n"
     ]
    }
   ],
   "source": [
    "for key, value in cast.items():\n",
    "    print(\"Actor: {}    Role: {}\".format(key, value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O items é um método incrível que retorna as tuplas de pares chave-valor, que você pode usar para iterar dicionários em loops for."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Loops while<a id='5'></a>\n",
    "---\n",
    "Loops `for` são um exemplo do significado de “iteração definida”, com o corpo do loop sendo executado um número pré-definido de vezes. Isso difere da \"iteração indefinida\", que é quando um loop é repetido um número desconhecido de vezes e só termina quando alguma condição for atendida, que é o que acontece em um loop `while`. Aqui está um exemplo de um loop `while`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "card_deck = [4, 11, 8, 5, 13, 2, 8, 10]\n",
    "hand = []\n",
    "\n",
    "# adds the last element of the card_deck list to the hand list\n",
    "# until the values in hand add up to 17 or more\n",
    "while sum(hand)  <= 17:\n",
    "    hand.append(card_deck.pop())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este exemplo apresenta duas novas funções. `sum` retorna a soma dos elementos em uma lista, e `pop` é um método de lista que remove o último elemento de uma lista e o retorna.\n",
    "#### Componentes de um loop `while`\n",
    "1. A primeira linha começa com a palavra-chave `while`, que indica que este é um loop `while`.\n",
    "2. Depois disso, a condição será verificada. Neste exemplo, a condição é `sum(hand) <= 17`.\n",
    "3. A abertura de um loop `while` sempre termina com dois pontos `:`.\n",
    "4. Indentado depois dessa abertura fica o corpo do loop `while`. Se a condição para o loop `while` for verdadeira, o corpo do loop será executado. Cada vez que o corpo do loop é executado, a condição é avaliada novamente. Esse processo de verificação da condição e execução do loop se repete até que a expressão se torne falsa.\n",
    "\n",
    "O corpo indentado do loop deve alterar pelo menos uma variável na expressão de teste. Se o valor da expressão teste nunca muda, o resultado é um loop infinito!\n",
    "\n",
    "### 6. Pausa e continuação<a id='6'></a>\n",
    "---\n",
    "Às vezes, precisamos de mais controle sobre quando deve terminar um loop, ou quando ignorar uma iteração. Nesses casos, usamos as palavras-chave `break` (pausar) e `continue` (continuar), que podem ser usadas em loops `for` e `while`.\n",
    "- `break` encerra um loop\n",
    "- `continue` ignora uma iteração de um loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Zip e Enumeração<a id='7'></a>\n",
    "---\n",
    "`zip` e `enumerate` (enumerar) são funções internas úteis que podem vir a calhar quando se lida com loops.\n",
    "\n",
    "#### 7.1. Zip\n",
    "`zip` retorna um iterador que combina múltiplos iteráveis em uma sequência de tuplas. Cada tupla contém os elementos nessa posição de todos os iteráveis. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 1), ('b', 2), ('c', 3)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(['a', 'b', 'c'], [1, 2, 3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como fizemos para `range()`, precisamos converter em uma lista ou iterar por meio dela com um loop para ver os elementos.\n",
    "\n",
    "Você pode desempacotar cada tupla em um loop `for` como este."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 1\n",
      "b: 2\n",
      "c: 3\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c']\n",
    "nums = [1, 2, 3]\n",
    "\n",
    "for letter, num in zip(letters, nums):\n",
    "    print(\"{}: {}\".format(letter, num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além de compactar duas listas juntas, você também pode descompactar uma lista usando um asterisco."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 'c')\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "some_list = [('a', 1), ('b', 2), ('c', 3)]\n",
    "letters, nums = zip(*some_list)\n",
    "\n",
    "print(letters)\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 7.1.1. Criando dicionários com `zip()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> ['Jetta Variant', 'Passat', 'Crossfox']\n",
      "<class 'list'> [88078.64, 106161.94, 72832.16]\n",
      "\n",
      "Juntando as duas listas em um dicionário com zip():\n",
      "<class 'dict'> {'Jetta Variant': 88078.64, 'Passat': 106161.94, 'Crossfox': 72832.16}\n"
     ]
    }
   ],
   "source": [
    "carros = ['Jetta Variant', 'Passat', 'Crossfox']\n",
    "valores = [88078.64, 106161.94, 72832.16]\n",
    "print('{} {}\\n{} {}'.format(type(carros), carros, type(valores), valores))\n",
    "dicio = dict(zip(carros, valores))\n",
    "print('\\nJuntando as duas listas em um dicionário com zip():\\n{} {}'.format(type(dicio), dicio))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2. Enumerate\n",
    "`enumerate` é uma função interna que devolve um iterador de tuplas contendo índices e valores para um lista. Você vai usar isso muitas vezes quando quiser o índice junto a cada elemento de um iterável em um loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n",
      "3 d\n",
      "4 e\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c', 'd', 'e']\n",
    "for i, letter in enumerate(letters):\n",
    "    print(i, letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Compreensão de listas<a id='8'></a>\n",
    "---\n",
    "Em Python, você pode criar listas rapidamente e de forma concisa com **compreensão de listas**. Este exemplo anterior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['New York City', 'Mountain View', 'Curitiba', 'Chicago', 'Los Angeles']\n"
     ]
    }
   ],
   "source": [
    "cities = ['new york city', 'mountain view', 'curitiba', 'chicago', 'los angeles']\n",
    "capitalized_cities = []\n",
    "for city in cities:\n",
    "    capitalized_cities.append(city.title())\n",
    "    \n",
    "print(capitalized_cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pode ser reduzido para:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['New York City', 'Mountain View', 'Curitiba', 'Chicago', 'Los Angeles']\n"
     ]
    }
   ],
   "source": [
    "cities = ['new york city', 'mountain view', 'curitiba', 'chicago', 'los angeles']\n",
    "capitalized_cities = [city.title() for city in cities]\n",
    "print(capitalized_cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compreensão de listas nos permite criar uma lista usando um loop `for` em uma única etapa.\n",
    "\n",
    "Você cria uma compreensão de listas com colchetes `[]`, incluindo uma expressão a ser avaliada para cada elemento em um iterável. Esta compreensão de lista acima puxa `city.title()` de cada elemento `city` em `cities`, para criar cada elemento na lista nova, `capitalized_cities`.\n",
    "\n",
    "#### Condicionais na compreensão de listas\n",
    "Você também pode adicionar condicionais para compreensão de listas (listcomps). Após o iterável, você pode usar a palavra-chave `if` para verificar uma condição em cada iteração."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "squares = [x**2 for x in range(9) if x % 2 == 0]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O código acima define `squares` como a lista `[0, 4, 16, 36, 64]`, já que `x` para a potência de 2 é avaliada somente se x for par. Se você quiser adicionar um `else`, receberá um erro de sintaxe fazendo isso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-29-0d53fcb29c35>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-29-0d53fcb29c35>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    squares = [x**2 for x in range(9) if x % 2 == 0 else x + 3]\u001b[0m\n\u001b[1;37m                                                       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "squares = [x**2 for x in range(9) if x % 2 == 0 else x + 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se quiser adicionar `else`, você deve mover condicionais para o início de listcomp, logo após a expressão, desta forma. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 4, 6, 16, 8, 36, 10, 64]\n"
     ]
    }
   ],
   "source": [
    "squares = [x**2 if x % 2 == 0 else x + 3 for x in range(9)]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"> <a href=\"#indice\">voltar ao topo </p>"
   ]
  }
 ],
 "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
}