Aula_9_Programacao_Funcional_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IEEE VTS Centro-Norte Brasil Chapter\n",
    "==\n",
    "Introdução à Programação com a Linguagem Python\n",
    "--"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programação Funcional em Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Função Lambda  \n",
    "Comandos zip, map, filter e reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Função Lambda\n",
    "\n",
    "Lambda é uma função anônima que aceitam argumentos e que só suporta uma expressão. Ao executar lambda, Python retorna uma função ao invés de atribuí-la à um nome como acontece com def, Ela é usada quando precisamos de uma função que não seja seja complexa o suficiente para criá-la com def. Podemos pensar em lambdas como funções de uma linha só."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "soma = lambda x,y : x + y\n",
    "#soma = lambda *x : sum(x)\n",
    "\n",
    "# def soma(x,y):\n",
    "#    return x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "soma(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "quadrado = lambda x: x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quadrado(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "par = lambda x:True if x%2==0 else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "par(17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "par(16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "729"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "potencia = {'quadrado': lambda x:x**2, \n",
    "            'cubo': lambda x:x**3,\n",
    "            'quarta': lambda x:x**4\n",
    "           }\n",
    "\n",
    "potencia['cubo'](9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "potencia['quadrado'](3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "343"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "potencia['cubo'](7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comando zip\n",
    "\n",
    "Esse comando recebe duas ou mais sequências não vazias e aplica determinada operação nos elementos de mesmo índice nas sequências."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x7facfc0f9fc8>\n"
     ]
    }
   ],
   "source": [
    "sq1 = [1,2,3,4,5,6,7,8]\n",
    "sq2 = ['a','b','c','d','e','f']\n",
    "z = zip(sq1,sq2)\n",
    "print(z)  #z éum objeto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'a')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(z)\n",
    "#z.__next__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana': 9, 'Leticia': 8, 'Raquel': 10}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nomes = ['Leticia', 'Ana', 'Raquel']\n",
    "notas = [8,9,10]\n",
    "dic_notas = dict(zip(nomes,notas))\n",
    "dic_notas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'gustavo': 2, 'rafael': 1, 'alifer': 0, 'henrique': 3}\n"
     ]
    }
   ],
   "source": [
    "alunos = ['alifer','rafael','gustavo','henrique']\n",
    "notas = [0,1,2,3]\n",
    "meu_dict = dict(zip(alunos,notas))\n",
    "print(meu_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]\n",
      "[1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96]\n"
     ]
    }
   ],
   "source": [
    "lista1 = list(range(11))\n",
    "lista2 = list(range(1,30,2))\n",
    "lista3 = list(range(1,100,5))\n",
    "print(lista1)\n",
    "print(lista2)\n",
    "print(lista3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1, 1),\n",
       " (1, 3, 6),\n",
       " (2, 5, 11),\n",
       " (3, 7, 16),\n",
       " (4, 9, 21),\n",
       " (5, 11, 26),\n",
       " (6, 13, 31),\n",
       " (7, 15, 36),\n",
       " (8, 17, 41),\n",
       " (9, 19, 46),\n",
       " (10, 21, 51)]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zipado = list(zip(lista1, lista2, lista3))\n",
    "zipado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10),\n",
       " (1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21),\n",
       " (1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51)]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deszipado = (zip(*zipado))\n",
    "list(deszipado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aplicando o zip com as comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sq1 = [1,2,3,4,5,6,7,8]\n",
    "sq2 = ['a','b','c','d','e','f']\n",
    "d3 = {x.upper():y for y,x in zip(sq1,sq2)}\n",
    "d3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('dois', 2)\n",
      "('quatro', 4)\n"
     ]
    }
   ],
   "source": [
    "for elem in {'dois':2,'quatro':4}.items():\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'f', 'b', 'd', 'c', 'e']\n",
      "[1, 6, 2, 4, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "s1 = [x.lower() for x in d3.keys()]\n",
    "s2 = [x for x in d3.values()]\n",
    "print(s1)\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')]\n"
     ]
    }
   ],
   "source": [
    "sq1 = [1,2,3,4,5,6,7,8]\n",
    "sq2 = ['a','b','c','d','e','f']\n",
    "z = zip(sq1,sq2)\n",
    "lista_do_zip = list(z)\n",
    "print(list(lista_do_zip))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2, 3, 4, 5, 6), ('a', 'b', 'c', 'd', 'e', 'f')]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zi = zip(*lista_do_zip)\n",
    "list(zi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a', 'w'), (2, 'b', 'e'), (3, 'c', 'r'), (4, 'd', 'y')]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sq1 = [1,2,3,4,5,6,7,8]\n",
    "sq2 = ['a','b','c','d','e','f']\n",
    "sq3 = ['w','e','r','y']\n",
    "z4 = zip(sq1,sq2,sq3)\n",
    "list(z4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 9, 'u'),\n",
       " (2, 8, 'm'),\n",
       " (3, 7, 'a'),\n",
       " (4, 6, ' '),\n",
       " (5, 5, 's'),\n",
       " (6, 4, 't'),\n",
       " (7, 3, 'r'),\n",
       " (8, 2, 'i')]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq1 = [1,2,3,4,5,6,7,8]\n",
    "seq2 = (9,8,7,6,5,4,3,2,1)\n",
    "seq3 = 'uma string legal'\n",
    "\n",
    "coisa_estranha = list(zip(seq1,seq2,seq3))\n",
    "coisa_estranha"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comando map:\n",
    "\n",
    "Essa função, em Python, serve para aplicarmos uma função a cada elemento de uma lista, retornando uma nova lista contendo os elementos resultantes da aplicação da função. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1048576"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def minha_funcao(x):\n",
    "    return x**10\n",
    "\n",
    "minha_funcao(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000000000"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minha_funcao(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq6 = [3,7,9,1,5,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
      "Wall time: 39.3 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[59049, 282475249, 3486784401, 1, 9765625, 282475249]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "[minha_funcao(x) for x in seq6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[59049, 282475249, 3486784401, 1, 9765625, 282475249]\n",
      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
      "Wall time: 236 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "resultados = map(minha_funcao,seq6)\n",
    "print(list(resultados))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando a função lambda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[59049, 282475249, 3486784401, 1, 9765625, 282475249]\n",
      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
      "Wall time: 235 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "resultados2 = map(lambda x:x**10,seq6)\n",
    "print(list(resultados2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comando Reduce:\n",
    "\n",
    "Reduce() está disponível no módulo functools. Sua utilidade está na aplicação de uma função a todos os valores do conjunto, de forma a agregá-los em um único valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq9 = [1,2,3,4,5,6,7,8,9,10]\n",
    "multiplica = reduce(lambda x,y:x*y,seq9)\n",
    "multiplica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefg'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq10 = ['a','b','c','d','e','f','g']\n",
    "multiplica2 = reduce(lambda x,y:x+y,seq10)\n",
    "multiplica2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1 = list(range(11))\n",
    "lista2 = list(range(1,30,2))\n",
    "lista3 = list(range(1,100,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "soma = reduce(lambda x,y:x+y**2,lista1)\n",
    "soma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4495"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "soma2 = reduce(lambda x,y:x+y**2,lista2)\n",
    "soma2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63670"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "soma3 = reduce(lambda x,y:x+y**2,lista3)\n",
    "soma3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9303746830339857, 0.8652304938358033, 0.19915740908932267, 0.050899186429773535, 0.09871202300663029, 0.17430662189919088, 0.12219158416206655, 0.5490900658938651, 0.29523642058809285, 0.6663641603875426]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "seq = [random.random() for x in range(10)]\n",
    "print(seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9303746830339857"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9303746830339857"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compara = lambda x,y: x if x>=y else y\n",
    "reduce(compara,seq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comando Filter:\n",
    "\n",
    "Como o próprio nome já diz, filter() filtra os elementos de uma sequência. O processo de filtragem é definido a partir de uma função passada como primeiro argumento. Assim, filter() só “deixa passar” para a sequência resultante aqueles elementos para os quais a chamada da função que o usuário passou retornar True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = 'aAbRmmmTTTBfgHHrTEB'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'm', 'm', 'm', 'f', 'g', 'r']"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resp = filter(lambda x:x.islower(), string)\n",
    "list(resp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'R', 'T', 'T', 'T', 'B', 'H', 'H', 'T', 'E', 'B']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resp = filter(lambda x: not x.islower(), string)\n",
    "list(resp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'R', 'T', 'T', 'T', 'B', 'H', 'H', 'T', 'E', 'B']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resp = filter(lambda x:x.isupper(), string)\n",
    "list(resp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista1 = list(range(11))\n",
    "maiores_que_quatro = filter(lambda x:x>4,lista1)\n",
    "list(maiores_que_quatro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['No',\n",
       " 'principio',\n",
       " 'era',\n",
       " 'o',\n",
       " 'Verbo',\n",
       " 'e',\n",
       " 'depois',\n",
       " 'veio',\n",
       " 'o',\n",
       " 'Substantivo']"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genesis_simplificado = 'No principio era o Verbo e depois veio o Substantivo'\n",
    "genesis_simplificado.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "e_titulo = lambda x : x.istitle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['No', 'Verbo', 'Substantivo']\n"
     ]
    }
   ],
   "source": [
    "print(list(filter(str.istitle,genesis_simplificado.split())))\n",
    "#print(list(filter(lambda x: x.istitle(),genesis_simplificado.split())))\n",
    "#print(list(filter(e_titulo,genesis_simplificado.split())))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vamos criar uma função que concatena listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def concatena(*listas):\n",
    "    saida = []\n",
    "    for lista in listas:\n",
    "        saida.extend(lista)\n",
    "    return saida"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6, 7, 3, 2, 5]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatena([1,2,3],[5,6,7],[3,2,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementando as funções builtin como funções ordinárias:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ZIP:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def meu_zip(*sequencias):\n",
    "    tamanho_minimo = min([len(elemento) for elemento in sequencias])\n",
    "    for i in range(tamanho_minimo):\n",
    "        yield(tuple([item[i] for item in sequencias]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "meus_zipados = meu_zip([1,2,3,5],[5,6,7],[3,2,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 3)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_zipados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### MAP:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def meu_map(funcao, sequencia):\n",
    "    for i in range(len(sequencia)):\n",
    "        yield(funcao(sequencia[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "meus_mappeds = meu_map(lambda x:x**2, [1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(meus_mappeds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_mappeds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_mappeds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_mappeds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_mappeds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### FILTER:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def meu_filter(funcao_booleana, sequencia):\n",
    "    sequencia = [item for item in sequencia if funcao_booleana(item)]\n",
    "    for elemento in sequencia:\n",
    "        yield(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "meus_filtrados = meu_filter(lambda x:x%2==0, [1,2,3,4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(meus_filtrados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_filtrados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_filtrados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(meus_filtrados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### RANGE:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def meu_range(*params):\n",
    "    passo = 1\n",
    "    if len(params)==1:\n",
    "        inicio = 0\n",
    "        numero = params[0]\n",
    "    elif len(params)==2:\n",
    "        inicio = params[0]\n",
    "        numero = params[1]\n",
    "    elif len(params)==3:\n",
    "        inicio = params[0]\n",
    "        numero = params[1]\n",
    "        passo = params[2]\n",
    "    else:\n",
    "        print('Deu ruim')\n",
    "        return\n",
    "    while inicio < numero:\n",
    "        yield inicio\n",
    "        inicio += passo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(meu_range(10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "print(list(meu_range(2,10,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### REDUCE:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def meu_reduce(funcao, sequencia):\n",
    "    resultado = sequencia[0]\n",
    "    for i in range(len(sequencia)-1):\n",
    "        resultado = funcao(resultado,sequencia[i+1])\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meu_reduce(lambda x,y:x+y, [1,2,3,4,5,6,7])"
   ]
  }
 ],
 "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": 1
}