Python - Tratamento de Arquivos, Módulos, Pacotes e Funções Built-in.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cap 4.5 - Função MAP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A função MAP aplica uma função a cada elemento de uma lista de valores\n",
    "# e retorna um interator que pode ser convertido para uma lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando duas funções\n",
    "\n",
    "# Função 1 - Recebe uma temperatura como parâmetro e retorna a temperatura em Farenheint\n",
    "def fahrenheit(T):\n",
    "    return((float(9)/5))*T + 32\n",
    "    \n",
    "# Função 2 - Recebe uma temperatura como parâmetro e retorna a temperatura em Celsius\n",
    "def celsius(T):\n",
    "    return(float(5)/9)*(T-32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fahrenheit(10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.1111111111111112"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "celsius(30)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando uma lista\n",
    "temperaturas = [0, 22.5, 40, 100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 22.5, 40, 100]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x501a470>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(fahrenheit,temperaturas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 22.5, 40, 100]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32.0, 72.5, 104.0, 212.0]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Função map() retornando a lista de temperaturas convertidas em Fahrenheit\n",
    "list(map(fahrenheit, temperaturas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32.0, 72.5, 104.0, 212.0]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(fahrenheit, temperaturas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32.0\n",
      "72.5\n",
      "104.0\n",
      "212.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "212.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Usando um loop for para imprimir o resultado da função map()\n",
    "for temp in map(fahrenheit, temperaturas):\n",
    "    print(temp)\n",
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-17.77777777777778, -5.277777777777778, 4.444444444444445, 37.77777777777778]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(celsius, temperaturas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x506e4a8>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convertendo para Celsius\n",
    "map(celsius, temperaturas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-17.77777777777778, -5.277777777777778, 4.444444444444445, 37.77777777777778]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(celsius, temperaturas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x506ec18>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Usando lambda\n",
    "map(lambda x: (5.0/9)*(x - 32), temperaturas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-17.77777777777778, -5.277777777777778, 4.444444444444445, 37.77777777777778]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: (5.0/9)*(x - 32), temperaturas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Somando os elementos de 2 listas\n",
    "a = [1,2,3,4]\n",
    "b = [5,6,7,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 8, 10, 12]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x,y:x+y, a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Somando os elementos de 3 listas\n",
    "a = [1,2,3,4]\n",
    "b = [5,6,7,8]\n",
    "c = [9,10,11,12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 18, 21, 24]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x,y,z:x+y+z, a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cap 4.6 - Função REDUCE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\n",
    "Reduce é uma função que recebe 2 argumentos (assim como a função map):\n",
    "\n",
    "    reduce(função, sequência)\n",
    "    \n",
    "O primeiro argumento é o nome de uma função e o segundo uma sequência (por exemplo, uma lista).\n",
    "\n",
    "Ao contrário da função MAP que aplica a função a cada elemento da sequência e retorna outra sequência de elementos, \n",
    "a função REDUCE aplica a função passada como parâmetro aos elementos da sequência, até que reste apenas um elemento.\n",
    "\n",
    "-->  MAP() e REDUCE() são conceitos principais em Data Science: a ideia de aplicar uma função em uma lista de valores \n",
    "até chegarmos num resultado menor. (no caso do Reduce, por exemplo)e poder aplicar alguma análise sobre um dado de grão menor.\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importando a função reduce do módulo functools\n",
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando uma lista\n",
    "lista = [47,11,42,13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[47, 11, 42, 13]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função\n",
    "def soma(a,b):\n",
    "    x = a + b\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "113"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Usando reduce com uma função e uma lista. A função vai retornar o valor mínimo.\n",
    "reduce(soma, lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image('arquivos/reduce.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando uma lista\n",
    "lst =[47, 11, 42, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "113"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Usando a função reduce() com lambda\n",
    "reduce(lambda x,y:x+y, lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podemos atribuir a expressão lambda a uma variável\n",
    "max_find2 = lambda a,b: a if (a > b) else b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(max_find2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reduzindo a lista até o valor máximo, através da função criada com a expressão lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(max_find2, lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Função FILTER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "A função filter() oferece uma maneira conveniente para filtrar todos os elementos de uma sequência, \n",
    "para os quais a função retorne True.\n",
    "\n",
    "filter(função, sequência)\n",
    "\n",
    "A exemplo das funções built-in, map() e reduce(), a função filter() também recebe 2 argumentos, \n",
    "uma função e uma sequência.\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando uma função\n",
    "def verificaPar(num):\n",
    "    if num % 2 == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Chamando a função e passando um número como parâmetro.\n",
    "# Retornará falso de for ímpar e True se for par.\n",
    "verificaPar(35)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [0,1,2,3,4,5,6,7,89,10,11,12,13,14,15,16,17,18]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 89, 10, 11, 12, 13, 14, 15, 16, 17, 18]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<filter at 0x511f5c0>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter(verificaPar,lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x: x%2==0, lista))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[89, 10, 11, 12, 13, 14, 15, 16, 17, 18]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda num: num > 8, lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Retornar cada caracter em uma sequência de caracteres\n",
    "lst = [x for x in 'python']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p', 'y', 't', 'h', 'o', 'n']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check\n",
    "lst\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variável x elevada ao quadrado para um range de números e retornar uma lista\n",
    "lst = [x for x in range(11) if x % 2 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minhaLista = [x**2 for x in range(10)]\n",
    "minhaLista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32.0, 50.0, 68.18, 94.1]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Converter Celsius para Fahrenheit\n",
    "celsius = [0,10,20.1,34.5]\n",
    "fahrenheit = [((float(9)/5)*temp + 32) for temp in celsius]\n",
    "fahrenheit\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Operações aninhadas\n",
    "lst = [ x**2 for x in [x**2 for x in range(11)]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Função ZIP "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando duas listas\n",
    "x = [1,2,3]\n",
    "y = [4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x512c288>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Unindo as listas. Em Python3 retorna um interator\n",
    "zip(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x512c048>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zip(y,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 4), (2, 5), (3, 6)]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Perceba que zip retorna tuplas. Neste caso, uma lista de tuplas\n",
    "list(zip(x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'x'), ('B', 'y')]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Atenção quando as sequências tiverem número diferente de elementos\n",
    "list(zip('ABCD', 'xy'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando duas listas\n",
    "a = [1,2,3]\n",
    "b = [4,5,6,7,8]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 4), (2, 5), (3, 6)]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando 2 dicionários\n",
    "d1 = {'a':1, 'b':2}\n",
    "d2 = {'c':4, 'd':5}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 4), ('b', 5)]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Zip pode unir os valores (itens)\n",
    "list(zip(d1,d2.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando uma função para trocar valores entre 2 dicionários\n",
    "def trocaValores(d1,d2):\n",
    "    dicTemp = {}\n",
    "    \n",
    "    for d1key, d2val in zip(d1,d2.values()):\n",
    "        dicTemp[d1key] = d2val\n",
    "        \n",
    "    return dicTemp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 4, 'b': 5}"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trocaValores(d1,d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Função Enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cria uma lista enumerada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criando uma lista\n",
    "seq = ['a','b', 'c']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<enumerate at 0x5124948>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enumerate(seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'a'), (1, 'b'), (2, 'c')]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transforma numa lista enumerada\n",
    "list(enumerate(seq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n"
     ]
    }
   ],
   "source": [
    "# Imprimindo os valores de uma lista com a função enumerate() e seus respectivos índices\n",
    "for indice, valor in enumerate(seq):\n",
    "    print (indice, valor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n"
     ]
    }
   ],
   "source": [
    "for indice, valor in enumerate(seq):\n",
    "    if indice >= 2:\n",
    "        break\n",
    "    else:\n",
    "        print (indice, valor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = ['Marketing', 'Tecnologia', 'Business']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Marketing', 'Tecnologia', 'Business']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Marketing\n",
      "1 Tecnologia\n",
      "2 Business\n"
     ]
    }
   ],
   "source": [
    "for i, item in enumerate(lista):\n",
    "    print(i, item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 I\n",
      "1 s\n",
      "2 s\n",
      "3 o\n",
      "4  \n",
      "5 é\n",
      "6  \n",
      "7 u\n",
      "8 m\n",
      "9 a\n",
      "10  \n",
      "11 s\n",
      "12 t\n",
      "13 r\n",
      "14 i\n",
      "15 n\n",
      "16 g\n"
     ]
    }
   ],
   "source": [
    "for i, item in enumerate('Isso é uma string'):\n",
    "    print(i, item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "1 1\n",
      "2 2\n",
      "3 3\n",
      "4 4\n",
      "5 5\n",
      "6 6\n",
      "7 7\n",
      "8 8\n",
      "9 9\n"
     ]
    }
   ],
   "source": [
    "for i, item in enumerate(range(10)):\n",
    "    print(i, item)"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}