Notebooks/07_Functional_Programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python  \n",
    "\n",
    "## [Functional Programming](https://docs.python.org/3/howto/functional.html) with Python:\n",
    "\n",
    "+ _lambda_ Functions  \n",
    "+ _zip_  \n",
    "+ _map_  \n",
    "+ _filter_  \n",
    "+ _reduce_  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lambda Functions\n",
    "\n",
    "When writing functional-style programs, you’ll often need little functions that act as predicates or that combine elements in some way. If there’s a Python built-in or a module function that’s suitable, you don’t need to define a new function at all, as in these examples:\n",
    "\n",
    "    stripped_lines = [line.strip() for line in lines]\n",
    "    existing_files = filter(os.path.exists, file_list)\n",
    "\n",
    "If the function you need doesn’t exist, you need to write it. One way to write small functions is to use the _lambda_ expression. lambda takes a number of parameters and an expression combining these parameters, and creates an anonymous function that returns the value of the expression:\n",
    "\n",
    "The pattern is:  \n",
    "     lambda: < variables > : operation(< variables >)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adder(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "adder = lambda x, y: x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adder(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "general_adder = lambda *x : sum(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "square = lambda x: x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_assign(name, value):\n",
    "    return name + '=' + str(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_assign = lambda name, value: name + '=' + str(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'year=2020'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print_assign('year',2020)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "even = lambda x:True if x%2==0 else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(even(17))\n",
    "print(even(16))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "729"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "potencia = {'square': lambda x:x**2, \n",
    "            'cube': lambda x:x**3,\n",
    "            'fourth': lambda x:x**4\n",
    "           }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "729\n",
      "9\n",
      "343\n"
     ]
    }
   ],
   "source": [
    "print(potencia['cube'](9))\n",
    "print(potencia['square'](3))\n",
    "print(potencia['cube'](7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funtional Tools: _zip_, _filter_, _map_ , _reduce_ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _zip_\n",
    "\n",
    "_zip_ function returns a _zip_ object (which is an iterator) that will aggregate elements from two or more iterables. You can use the resulting iterator to solve common tasks, like creating dictionaries.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x7f9c6006f388>\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'a')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(z)\n",
    "#z.__next__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Leticia': 8, 'Ana': 9, 'Raquel': 10}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = ['Leticia', 'Ana', 'Raquel']\n",
    "grades = [8,9,10]\n",
    "dic_grades = dict(zip(names,grades))\n",
    "dic_grades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Diogo': 0, 'Rafael': 1, 'Gustavo': 2, 'Deborah': 3}\n"
     ]
    }
   ],
   "source": [
    "students = ['Diogo','Rafael','Gustavo','Deborah', 'Extra Student']\n",
    "grades = [0,1,2,3]\n",
    "new_dict_grades = dict(zip(students,grades))\n",
    "print(new_dict_grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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": [
    "list1 = list(range(11))\n",
    "list2 = list(range(1,30,2))\n",
    "list3 = list(range(1,100,5))\n",
    "print(list1)\n",
    "print(list2)\n",
    "print(list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zipped = list(zip(list1, list2, list3))\n",
    "zipped"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to reverse a zip command?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unzipped = (zip(*zipped))\n",
    "list(unzipped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Zip with comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6}"
      ]
     },
     "execution_count": 30,
     "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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f']\n",
      "[1, 2, 3, 4, 5, 6]\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": 34,
   "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",
    "print(list(z))"
   ]
  },
  {
   "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",
    "print(list(z4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 9, 'A'), (2, 8, ' '), (3, 7, 'n'), (4, 6, 'i'), (5, 5, 'c'), (6, 4, 'e'), (7, 3, ' '), (8, 2, 's')]\n"
     ]
    }
   ],
   "source": [
    "seq1 = [1,2,3,4,5,6,7,8]\n",
    "seq2 = (9,8,7,6,5,4,3,2,1)\n",
    "seq3 = 'A nice string'\n",
    "\n",
    "print(list(zip(seq1,seq2,seq3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _map_\n",
    "\n",
    "_map_ function returns a map object (which is an iterator) of the results after applying the given function to each item of a given iterable (list, tuple etc.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(x):\n",
    "    return x**10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1048576\n",
      "10000000000\n"
     ]
    }
   ],
   "source": [
    "print(my_function(4))\n",
    "print(my_function(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq6 = [3,7,9,1,5,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[59049, 282475249, 3486784401, 1, 9765625, 282475249]\n",
      "CPU times: user 267 µs, sys: 25 µs, total: 292 µs\n",
      "Wall time: 223 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "results = map(my_function, seq6)\n",
    "print(list(results))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 19 µs, sys: 2 µs, total: 21 µs\n",
      "Wall time: 28.6 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[59049, 282475249, 3486784401, 1, 9765625, 282475249]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "[my_function(x) for x in seq6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[59049, 282475249, 3486784401, 1, 9765625, 282475249]\n",
      "CPU times: user 257 µs, sys: 25 µs, total: 282 µs\n",
      "Wall time: 217 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "results = map(lambda x:x**10, seq6)\n",
    "print(list(results))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _reduce_\n",
    "\n",
    "The reduce() function in Python takes in a function and a list as argument. The function is called with a lambda function and a list and a new reduced result is returned. This performs a repetitive operation over the pairs of the list. This is a part of functools module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq9 = [1,2,3,4,5,6,7,8,9,10]\n",
    "multiply = reduce(lambda x,y:x*y, seq9)\n",
    "multiply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefg'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq10 = ['a','b','c','d','e','f','g']\n",
    "concatenate = reduce(lambda x,y:x+y, seq10)\n",
    "concatenate"
   ]
  },
  {
   "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,
    "jupyter": {
     "outputs_hidden": 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,
    "jupyter": {
     "outputs_hidden": 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,
    "jupyter": {
     "outputs_hidden": 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,
    "jupyter": {
     "outputs_hidden": 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,
    "jupyter": {
     "outputs_hidden": 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,
    "jupyter": {
     "outputs_hidden": 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,
    "jupyter": {
     "outputs_hidden": 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,
    "jupyter": {
     "outputs_hidden": 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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}