Notebooks/draft/Aula_7_Comprehensions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FGV - Escola de Matemática Aplicada\n",
    "==\n",
    "Introdução à Programação com a Linguagem Python\n",
    "--"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python temos existem construções sintáticas que permitem a construção de sequências de maneira mais clara e concisa. São elas:\n",
    "\n",
    "- list comprehension\n",
    "- set comprehension\n",
    "- dict comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma list comprehension é uma maneira concisa de construir uma lista preenchida. Um uso comum é construir uma nova lista onde cada elemento é o resultado de alguma expressão aplicada a cada membro de outra sequência ou iterável, ou para construir uma subsequência cujos elementos satisfazem uma certa condição."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ela irá seguir um modelo:  lista = [\"expressão\" for \"elemento\" in \"sequência\" if \"condição\"]. \n",
    "\n",
    "Vejamos o código abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubos = []\n",
    "for elementos in range(10):\n",
    "    cubos.append(elementos**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n"
     ]
    }
   ],
   "source": [
    "print(cubos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos reescrevê-lo de forma mais concisa utilizando a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubos2 = [elementos**3 for elementos in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n"
     ]
    }
   ],
   "source": [
    "print(cubos2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir temos mais um exemplo da conversão para a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "156390386\n",
      "0.0013773441314697266\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "lista = []\n",
    "for x in range(1001):\n",
    "    if x%5==0 or x%3==0:\n",
    "        lista.append(x**2)\n",
    "print(sum(lista))\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0009145736694335938\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "lc2 = [x**2 for x in range(1001) if x%5==0 or x%3==0]\n",
    "sum(lc2)\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lc2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outros exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 11)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequencia = range(11)\n",
    "sequencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(sequencia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64, 100]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[elemento**2 for elemento in sequencia if elemento%2==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 14, 11]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x+y for x,y in [(9,4),(8,6),(2,9)]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 5, 5, 5]\n",
      "0.0004055500030517578\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "print([3+2 for numero in range(4)])\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 5, 5, 5]\n",
      "0.00036072731018066406\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "print(4 * [5])\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 9, 8]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minha_lista = [x + y for x,y in [(2,3),(4,5),(1,7)]]\n",
    "minha_lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 81, 0, 16]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1, \"4\", 9, \"a\", 0, 4]\n",
    "quadrado_inteiros = [i**2 for i in lista if type(i) == int]\n",
    "quadrado_inteiros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Podemos fazer  uma list comprehension com múltiplos loops:\n",
    "\n",
    "Veja o código a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5)]\n"
     ]
    }
   ],
   "source": [
    "pontos = []\n",
    "for x in [1,2,3]:\n",
    "    for y in [3,4,5]:\n",
    "        if x != y:\n",
    "            pontos.append((x,y))\n",
    "print(pontos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos reescrevê-lo dessa forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5)]\n"
     ]
    }
   ],
   "source": [
    "pontos = [(x,y) for x in [1,2,3] for y in [3,4,5] if x != y] # os loops serão postos, sem separação (somente um espaço), na mesma sequência do código original.\n",
    "print(pontos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aplicando a list comprehension em listas de strings:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Importando o pacote string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.punctuation #nos dá as pontuações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0123456789'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.digits #nos dá os números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.ascii_letters #nos dá as letras do alfabeto (ordenadas) minúsculas e maiúsculas, nessa ordem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefghijklmnopqrstuvwxyz'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.ascii_lowercase #somente as letras minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.ascii_uppercase #somente as letras maiúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0123456789abcdefABCDEF'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.hexdigits #nos d´s os dígitos hexadecimais."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que já conhecemos brevemente o pacote string, vamos aplicar a list comprehension: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = 'Uma string. Escrevi! Vocês duvidam? Claro, tem que ver para crer'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Uma',\n",
       " 'string.',\n",
       " 'Escrevi!',\n",
       " 'Vocês',\n",
       " 'duvidam?',\n",
       " 'Claro,',\n",
       " 'tem',\n",
       " 'que',\n",
       " 'ver',\n",
       " 'para',\n",
       " 'crer']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string.split() #O .split() \"quebrará\" a string nos seus espaços criando uma lista, e cada \"parte\" corresponderá a um elemento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Uma',\n",
       " 'string.',\n",
       " 'Escrevi!',\n",
       " 'Vocês',\n",
       " 'duvidam?',\n",
       " 'Claro,',\n",
       " 'tem',\n",
       " 'que',\n",
       " 'ver',\n",
       " 'para',\n",
       " 'crer']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[token for token in my_string.split()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['uma',\n",
       " 'string.',\n",
       " 'escrevi!',\n",
       " 'vocês',\n",
       " 'duvidam?',\n",
       " 'claro,',\n",
       " 'tem',\n",
       " 'que',\n",
       " 'ver',\n",
       " 'para',\n",
       " 'crer']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[token.lower() for token in my_string.split()] #.lower() passará todas as letras maiúsculas para minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Uma',\n",
       " 'string',\n",
       " 'Escrevi',\n",
       " 'Vocês',\n",
       " 'duvidam',\n",
       " 'Claro',\n",
       " 'tem',\n",
       " 'que',\n",
       " 'ver',\n",
       " 'para',\n",
       " 'crer']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[token.strip(string.punctuation) for token in my_string.split()] #.strip(x) retirará da lista, no caso a lista token, os elementos de x, que aqui são as pontuações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'.pala.vra'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'.pala.vra.'.rstrip('.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['uma',\n",
       " 'string',\n",
       " 'escrevi',\n",
       " 'vocês',\n",
       " 'duvidam',\n",
       " 'claro',\n",
       " 'tem',\n",
       " 'que',\n",
       " 'ver',\n",
       " 'para',\n",
       " 'crer']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[token.lower().strip(string.punctuation) for token in my_string.split()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Set Comprehension:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As set comprehensions permitem que conjuntos sejam construídos usando os mesmos princípios que as compreensões de lista, a única diferença é que a seqüência resultante é um conjunto.\n",
    "\n",
    "Seguiremos o modelo, apenas trocando os colchetes (da list comprehension) por chaves: conjunto = {\"expressão\" for \"elemento\" in \"sequência\" if \"condição\"}.\n",
    "\n",
    "Vejamos o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 4, 9, 16}\n"
     ]
    }
   ],
   "source": [
    "quadrados = {i**2 for i in range(5)}\n",
    "print(quadrados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'v', 'c', 'r', 'd', 's'}\n"
     ]
    }
   ],
   "source": [
    "consoantes = {letra for letra in 'cursodeverao' if letra not in \"aeiou\" }\n",
    "print(consoantes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'o', 'e'}\n"
     ]
    }
   ],
   "source": [
    "vogais = {letra for letra in \"pythonlovers\" if letra in \"aeiou\"}\n",
    "print(vogais)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) Dict Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos escrever dicionários de sucinta usando dict comprehension. Devemos tomar cuidado pois o dicionário distingue letras maiúsculas de minúsculas.\n",
    "\n",
    "Usamos o modelo: dicionario = {'elemento' : 'operação' for 'elemento' in 'sequência' if 'condição'}\n",
    "\n",
    "Vejamos os seguintes exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9}\n"
     ]
    }
   ],
   "source": [
    "quadrado = {x:x**2 for x in range(4)}\n",
    "print(quadrado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'primeiro': 1, 'segundo': 2}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d0 = {x:y for x,y in [('primeiro',1),('segundo',2)]}\n",
    "d0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'UM': 1, 'TRES': 3, 'DOIS': 2}\n",
      "0.0004951953887939453\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "d1 = {x.upper():y for x,y in [('um',1),('dois',2),('tres',3)]}\n",
    "print(d1)\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'um': 1, 'dois': 2, 'tres': 3}\n",
      "0.0008649826049804688\n"
     ]
    }
   ],
   "source": [
    "t0 = time.time()\n",
    "d2 = dict([('um',1),('dois',2),('tres',3)])\n",
    "print(d2)\n",
    "print(time.time() - t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 1, 2: 3, 4: 5, 6: 7}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{x:y for x,y in zip(range(0,7,2), range(1,8,2))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DOIS': 2, 'TRES': 3, 'UM': 1}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d3 = {chave.upper():valor for chave, valor in d2.items()}\n",
    "d3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('um', 1), ('dois', 2)])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 'um', 2: 'dois'}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dicionario = {'um':1, 'dois':2}\n",
    "print(dicionario.items())\n",
    "{valor:chave for chave,valor in dicionario.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('UM', 1), ('TRES', 3), ('DOIS', 2)])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d3.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DOIS': 3, 'TRES': 4, 'UM': 2}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4 = {chave:valor+1 for chave,valor in d3.items()}\n",
    "d4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('UM', 2)\n",
      "('TRES', 4)\n",
      "('DOIS', 3)\n"
     ]
    }
   ],
   "source": [
    "for alguma_coisa in d4.items():\n",
    "    print(alguma_coisa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 7, 2: 3, 4: 5}"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{chave:valor for chave,valor in [(2,3),(4,5),(1,7)]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "disciplinas = ['Cálculo', 'IntroComp', 'ModelagemII']\n",
    "notas = [8,8.5,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Cálculo': 8, 'IntroComp': 8.5, 'ModelagemII': 9}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{disciplina:nota for disciplina,nota in zip(disciplinas, notas)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}