Python II.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:blue\">Programação Python para Ciência de Dados</span>\n",
    "## <span style=\"color:blue\">Módulo 2: Python II</span>\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Conteúdo:__\n",
    "- Referências\n",
    "- Operações em tipos sequenciais (sequence types)\n",
    "- Comprehensions\n",
    "- Funções avançadas\n",
    "- Arquivos E/S (File I/O)\n",
    "\n",
    "__Referencias:__\n",
    "- Mark Lutz, Learning Python, O'Reilly, 2013\n",
    "- Eric Matthes, Python Crash Course: A Hands-On, Project-Based Introduction to Programming, No Starch Press, 2015"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Referências \n",
    "\n",
    "Atribuição manipula referências:\n",
    "```python\n",
    "x = y\n",
    "```\n",
    "não é feita cópia do conteúdo de $y$, isto é, $x$ apenas passa a referênciar o que $y$ referencia.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constantes são imutáveis:\n",
    "- inteiros (integer) e números reais (float)\n",
    "- strings\n",
    "- tuplas\n",
    "\n",
    "então o que realmente ocorre, no que diz respeito a referências, é o seguinte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "x = x+1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "x = 3\n",
    "```\n",
    "o número 3 é uma constante criada na memória, e a variável $x$ referencia ao endereço dessa constante \n",
    "```python\n",
    "x = x+1\n",
    "```\n",
    "na expressão x+1, o valor 3 referenciado por x é recuperado, adicionado 1 e o resultado 4 é colocado em um novo endereço de memória. $x$ é atualizado de maneira a referenciar o endereço da nova constante 4.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94731079287904\n",
      "94731079287936\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print(id(x))\n",
    "x = x+1\n",
    "print(id(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 3\n"
     ]
    }
   ],
   "source": [
    "# Por que a variável y não muda com x?Pq está em outro local da memória\n",
    "x = 3\n",
    "y = x\n",
    "x = x+1\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2] [3, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "# Por que a variável y muda com x? Pq está no mesmo local da memória\n",
    "x = [3]\n",
    "y = x\n",
    "x.append(1)\n",
    "y.append(2)\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1] [3, 2]\n"
     ]
    }
   ],
   "source": [
    "# Por que a variável y não muda com x? Pq está em outro local da memória\n",
    "x = [3]\n",
    "y = x\n",
    "x = x+[1]\n",
    "y = y+[2]\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Operações em sequências"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">\"in\"</span>\n",
    "- Verifica se um valor está em uma sequência \n",
    "- Testa substrings em strings \n",
    "- Verifica se valor é uma chave de um dicionário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "t = [1,2,3,4,5]\n",
    "print(3 in t)\n",
    "print(7 in t)\n",
    "print(3 not in t)\n",
    "print(7 not in t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s = 'abcde'\n",
    "print('cd' in s)\n",
    "print('acd' in s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "d = {'Brasil' : 'PT-BR', 'Espanha' : 'Es'}\n",
    "print('Brasil' in d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Atenção__:\n",
    "o perador `in` também é usado em `for` loops (assim como em list comprehension), porém, com um objetivo diferente. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">\"+\"</span>\n",
    "- produz uma nova sequência em que o valor é a concatenação dos argumentos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140713463680888\n",
      "(1, 2, 3, 4, 5, 6)\n",
      "140713523460232\n"
     ]
    }
   ],
   "source": [
    "a = (1,2,3)\n",
    "print(id(a))\n",
    "b = (4,5,6)\n",
    "a = a+b\n",
    "print(a) # Produz elemento em outro local da memória\n",
    "print(id(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "helloworld\n"
     ]
    }
   ],
   "source": [
    "print([1,2,3]+[4,5,6])\n",
    "print('hello'+'world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">\"*\"</span>\n",
    "- argumentos devem ser um inteiro e uma sequência\n",
    "- produz uma nova sequência em que os elementos são replicados o número de vezes do inteiro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 1, 2, 3, 1, 2, 3)\n",
      "[1, 2, 3, 1, 2, 3]\n",
      "ababababab\n"
     ]
    }
   ],
   "source": [
    "print(3*(1,2,3))\n",
    "print(2*[1,2,3])\n",
    "print(5*'ab')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operações exclusivas de listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">\"append\"</span>, <span style=\"color:blue\">\"insert\"</span> e <span style=\"color:blue\">\"extend\"</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 'a']\n",
      "[1, 'b', 2, 3, 4, 5, 'a']\n",
      "[1, 'b', 2, 3, 4, 5, 'a', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4,5]\n",
    "lst.append('a') # acrescenta elemento ao final da lista\n",
    "print(lst)\n",
    "lst.insert(1,'b') # insere em posição especificada (pode ser muito custoso)\n",
    "print(lst)\n",
    "lst.extend(['c','d']) # acrescenta elementos de uma outra lista ao final da anterior, mantém local da memória\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a']\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', ['a']]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', ['a', 'b']]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', ['a', 'b'], 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "l = list(range(10))\n",
    "print(l)\n",
    "l.append('a')\n",
    "print(l)\n",
    "l.append(['a'])\n",
    "print(l)\n",
    "l[-1].append('b')\n",
    "print(l)\n",
    "l.extend(['c','d'])\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Atenção:__\n",
    "- `extend` usa a lista em questão enquanto o `+` cria uma nova lista\n",
    "- `extend` assume uma LISTA como argumento enquanto `append` assume um elemento como argumento (o elemento pode ser uma outra lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">\"index\"</span>, <span style=\"color:blue\">\"count\"</span>, <span style=\"color:blue\">\"reverse\"</span>, <span style=\"color:blue\">\"sort\"</span> e <span style=\"color:blue\">\"remove\"</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'b', 'e', 'b']\n",
      "index 1\n",
      "count 3\n",
      "sorted ['a', 'b', 'b', 'b', 'c', 'e']\n",
      "reversed ['e', 'c', 'b', 'b', 'b', 'a']\n"
     ]
    }
   ],
   "source": [
    "xst = ['a', 'b', 'c', 'b','e','b']\n",
    "print(xst)\n",
    "print('index',xst.index('b')) # dá o indice da primeira ocorrência\n",
    "print('count',xst.count('b')) # conta o numero de ocorrências\n",
    "xst.sort() # ordena os elementos da lista \"in place\" \n",
    "#xst.sort(reverse=True) # ordena os elementos da lista \"in place\" ao contrário\n",
    "print('sorted',xst)\n",
    "xst.reverse() # reverte a ordem dos elementos na lista \"in place\"\n",
    "print('reversed',xst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Atenção:__ Todas as operações _sort_ e _reverse_ são _\"in place\"_ (modificam a variável em questão) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">\"remove\"</span>, <span style=\"color:blue\">\"pop\"</span> e <span style=\"color:blue\">\"del\"</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['e', 'c', 'b', 'b', 'b', 'a']\n",
      "removig the first b ['e', 'c', 'b', 'b', 'a']\n",
      "delete element in position 1  ['e', 'b', 'b', 'a']\n",
      "popped ['e', 'b', 'b']\n"
     ]
    }
   ],
   "source": [
    "print(xst)\n",
    "xst.remove('b') # remove primeira ocorrencia\n",
    "print('removig the first b',xst)\n",
    "\n",
    "del xst[1] # remove pelo indice\n",
    "print('delete element in position 1 ',xst)\n",
    "\n",
    "xst.pop() # remove do topo (ultima posição) da lista (tende a ser um pouco mais eficiente que os anteriores)\n",
    "print('popped',xst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### <span style=\"color:blue\">\"sorted\"</span>, <span style=\"color:blue\">\"max\"</span>, <span style=\"color:blue\">\"min\"</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sorted: [0.28099898080227304, 0.5190578862162447, 0.9362888526747843]\n",
      "original: [0.9362888526747843, 0.28099898080227304, 0.5190578862162447]\n",
      "max: 0.9362888526747843\n",
      "min: 0.28099898080227304\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "seq = [random.random() for i in range(3)]\n",
    "\n",
    "#print(seq)\n",
    "print('sorted:', sorted(seq)) #sortED não modifica a sequência, e gera uma nova lista com os elementos em sequencia\n",
    "print('original:', seq)\n",
    "print('max:', max(seq))\n",
    "print('min:', min(seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Comprehension\n",
    "Controi uma nova lista aplicando uma expressão para cada item em um sequência\n",
    "```python\n",
    "l = [expression for target in object]\n",
    "```\n",
    "é equivalente a:\n",
    "```python\n",
    "l=[]\n",
    "for target in object:\n",
    "    l.append(expression)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81, 64, 49, 36, 25, 16, 9, 4, 1, 0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "cst = [i**2 for i in range(-9,10)]\n",
    "print(cst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comprehension é mais eficiente do que `for` loop "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "117 µs ± 11.1 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit #magic functions do jupyter, roda várias vezes e testa a velocidade do código\n",
    "cst = [i**2 for i in range(-100,100)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "122 µs ± 429 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "l = []\n",
    "for i in range(-100,100):\n",
    "    l.append(i**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### __Comprehension com Filtragem__:\n",
    "```python\n",
    "l = [expression for target in object if condition] #Python fica mais rápido pq ele compara uma vez se a variável é do memo tipo e já dispara. No caso do for com if ele tem que comparar todas as vezes as variáveis, tomando mais tempo.\n",
    "```\n",
    "é equivalente a:\n",
    "```python\n",
    "l=[]\n",
    "for target in object:\n",
    "    if condition:\n",
    "        l.append(expression)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81, 49, 25, 9, 1, 1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "l = [x**2 for x in range(-10,10) if x%2 != 0] # inclui apenas números ímpares\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__OBS__: a condição `if` funciona como filtro. Mas quando uma declaração do tipo `if` `else` precisa ser usada, então é inserida antes do for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 81, 0, 49, 0, 25, 0, 9, 0, 1, 0, 1, 0, 9, 0, 25, 0, 49, 0, 81]\n"
     ]
    }
   ],
   "source": [
    "l = [x**2  if x%2 != 0 else 0 for x in range(-10,10)] # impares intercalados com zero\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### __Laços Encapsulados (Nested Loops)__:\n",
    "```python\n",
    "l = [expression\tfor target1 in object1 if condition1\n",
    "\t\t\t\t\tfor target2 in object2 if condition2\n",
    "\t\t\t\t\t...]\n",
    "```\n",
    "é equivalente a:\n",
    "```python\n",
    "l=[]\n",
    "for target1 in object1:\n",
    "    if condition1:\n",
    "        for target2 in object2:\n",
    "            if condition2:\n",
    "                ...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 3, 4, 5, 4, 5, 6, 7, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10, 11, 7, 8, 9, 10, 11, 12, 13, 8, 9, 10, 11, 12, 13, 14, 15, 9, 10, 11, 12, 13, 14, 15, 16, 17]\n"
     ]
    }
   ],
   "source": [
    "l = [x+y for x in range(-10,10) for y in range(10) if y < x]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 3, 4, 5, 4, 5, 6, 7, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10, 11, 7, 8, 9, 10, 11, 12, 13, 8, 9, 10, 11, 12, 13, 14, 15, 9, 10, 11, 12, 13, 14, 15, 16, 17]\n"
     ]
    }
   ],
   "source": [
    "# codigo equivalente ao comprehension\n",
    "\n",
    "l=[]\n",
    "for x in range(-10,10):\n",
    "    for y in range(10):\n",
    "        if y < x:\n",
    "            l.append(x+y)\n",
    "            \n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Comprehension\n",
    "Também é possível criar dicionários usando comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
     ]
    }
   ],
   "source": [
    "dt = {x:x**2 for x in range(10)}\n",
    "print(dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Objetos função\n",
    "Uma função criada pelo comando `def` é um objeto em Python. Vale dali pra baixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello 1\n",
      "Hello 2\n"
     ]
    }
   ],
   "source": [
    "def echo(x):\n",
    "    print(x)\n",
    "    \n",
    "echo('Hello 1')\n",
    "x = echo\n",
    "x('Hello 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os parâmetros de uma função podem assumir valores \"default\" que são utilizados quando o parâmetro não é fornecido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "8\n",
      "8\n",
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def echo2(x=10,y=7):\n",
    "    print(x+y)\n",
    "    \n",
    "echo2()\n",
    "echo2(x=1)\n",
    "echo2(1)\n",
    "echo2(x=1,y=0)\n",
    "echo2(1,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toda função retorna algo. Se o comando _return_ não é especificado, _None_ é retornado como resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def soma1(x):\n",
    "    x+1\n",
    "    \n",
    "def soma2(x):\n",
    "    return(x+2)\n",
    "    \n",
    "print(soma1(1))\n",
    "print(soma2(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim como um objeto, funções podem ser passadas como argumento para outras funções"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def echo(x):\n",
    "    print(x)\n",
    "    \n",
    "def call_echo(f,t):\n",
    "    f(t)\n",
    "\n",
    "call_echo(echo,'Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma função pode retornar um objeto função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "def f1(param1): # é como se ele tivesse criado um objeto da classe função, com um método f2 e um parametro f1\n",
    "    def f2(param2):\n",
    "        print(param1+param2)\n",
    "    return(f2)\n",
    "\n",
    "g = f1('Hello ') # param1 is stored as a variable of f2, vai retornar um ponteiro para a função 2\n",
    "g('World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "f1('Hello ')('world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Funções Lambda\n",
    "- _Funções lambda (Lambda Functions)_ são funções que podem ser chamadas mas não possuem nome #Testa a variável uma vez só\n",
    "- Uma `lambda` é uma expressão, não uma declaração, então pode ser usada em lugares do código em que `def` não é válido\n",
    "```python\n",
    "lambda arg1,arg2,...,argn: expression\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "f1_l = lambda x: x**2\n",
    "print(f1_l(2))\n",
    "\n",
    "f2_l = lambda x,y: x+y\n",
    "print(f2_l(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "f3_l = lambda x: 'even' if x%2==0 else 'odd'\n",
    "eo = [i for i in range(10) if f3_l(i) == 'even' ]\n",
    "print(eo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5, -6, 6, -7, 7, -8, 8, -9, 9, -10]\n"
     ]
    }
   ],
   "source": [
    "l = [i for i in range(-10,10)]\n",
    "l.sort(key=lambda x: abs(x))#vc quer ordenar baseado no resultado de uma função. Não dá pra usar def.\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Programação Funcional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map\n",
    "```python\n",
    "map(func,iterable)\n",
    "```\n",
    "aplica 'func' a todos os elementos do 'iterable'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a_hi', 'b_hi', 'c_hi', 'd_hi']\n",
      "['a_hi', 'b_hi', 'c_hi', 'd_hi']\n",
      "['a_hi', 'b_hi', 'c_hi', 'd_hi']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "def echo2(a):\n",
    "    return(a+'_hi')\n",
    "    \n",
    "l = list(map(echo2,'abcd')) # Voce tem que dizer o que ele vai ser. No caso sem o list ele retorna um iterador.\n",
    "\n",
    "# Equivalento ao código abaixo\n",
    "ll = []\n",
    "for s in 'abcd':\n",
    "    ll.append(echo2(s))\n",
    "\n",
    "a = map(echo2,'abcd')    # Utiliza uma vez o iterador, ver segundo print do a\n",
    "    \n",
    "print(l)\n",
    "print(ll)\n",
    "print(list(a))\n",
    "print(list(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a_oi', 'b_oi', 'c_oi', 'd_oi']\n"
     ]
    }
   ],
   "source": [
    "l = list(map(lambda x: x+'_oi','abcd'))\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### filter \n",
    "```python\n",
    "filter(func,iterable)\n",
    "```\n",
    "retorna todos os elementos do 'iterable' em que 'func' retorna <span style='color:blue'> True </span> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "l = list(filter(lambda x: x%2==0,range(10)))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reduce \n",
    "```python\n",
    "reduce(func,iterable, init)# Muito útil para fazer multiplicação de matrizes. Se eu especificar o init ele pega o primeiro com o init, se eu não especificar ele começa com os dois primeiros\n",
    "```\n",
    "aplica 'func' acumulativamente aos itens do 'iterable', da esquerda para a direita, de maneira a reduzir a sequência 'iterable' a apenas um elemento\n",
    "- a função 'func' sempre precisa receber dois argumentos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "45\n",
      "46\n",
      "45\n",
      "45\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "r = reduce(lambda x,y: x+y,range(10))# x é onde ele acumula e o y é o que vem do range\n",
    "print(r)\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "rr = reduce(lambda x,y: x+y,range(10),1)# x é onde ele acumula e o y é o que vem do range\n",
    "print(r)\n",
    "print(rr)\n",
    "# equivalent to\n",
    "x = 0\n",
    "for y in range(10):\n",
    "    x = x + y\n",
    "print(x)\n",
    "\n",
    "# equivalent to\n",
    "x = 0\n",
    "for y in range(10):\n",
    "    x = x + y\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[-1], [0], [1], [2], [3], [4], [5], [6], [7], [8], [9]]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x, y : x + y, [[[i]] for i in range(10)], [[-1]]) # ele está concatenando"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x, y : x + y, [i for i in range (1,5)]) # ele está concatenando"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Arquivos E/S (File I/O)\n",
    "- Python manipula naturalmente arquivos _ascii_, mas arquivos binários também são possíveis de serem usados\n",
    "- O conteúdo de um arquivo é um string, não um objeto. Então o usuário deve fazer a conversão de/para string \n",
    "- Arquivos são lidos/escritos em buffers, o que significa que deve-se assegurar o dump para disco no código Python\n",
    "   - fechar um arquivo (comando close em Python) ou usar o comando `flush` força os dados em buffer a serem escritos em disco"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### open\n",
    "```python\n",
    "open(filename, mode)\n",
    "``` \n",
    "retorna um obejeto arquivo.<br>\n",
    "\n",
    "\"mode\" pode ser\n",
    "- ‘r’ para leitura (read)\n",
    "- ‘w’ para escrita(write)\n",
    "- ‘a’ para acrescentar (append)\n",
    "- ‘r+’ para leitura e escrita\n",
    "\n",
    "Se o arquivo não pode ser aberto, o interpretador envia a mensagem de erro IOError<br>\n",
    "Métodos no objeto arquivo são usados para ler, escrever e controlar o arquivo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing data.txt\n"
     ]
    }
   ],
   "source": [
    "%%writefile data.txt \n",
    "# Magic function que roda tudo que está na célula\n",
    "# o comando acima envia o conteúdo desta célula para\n",
    "# um arquivo texto chamado 'data.txt'\n",
    "\n",
    "hello world\n",
    "today is Wednesday\n",
    "winter is comming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instanciando um objeto 'arquivo'\n",
    "f = open('data.txt','r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### read\n",
    "```python\n",
    "f.read(size)\n",
    "``` \n",
    "lê \"size\" bytes, ou o arquivo inteiro se \"size\" é omitido\n",
    "```python\n",
    "f.readline() \n",
    "``` \n",
    "lê uma única linha\n",
    "```python\n",
    "for line in f: \n",
    "```\n",
    "lê cada linha do arquivo atribuindo-a a variável \"line\" \n",
    "```python\n",
    "f.readlines() \n",
    "```\n",
    "retorna uma lista contendo todas as linhas do arquivo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['# Magic function que roda tudo que estÃ¡ na cÃ©lula\\n', '# o comando acima envia o conteÃºdo desta cÃ©lula para\\n', \"# um arquivo texto chamado 'data.txt'\\n\", '\\n', 'hello world\\n', 'today is Wednesday\\n', 'winter is comming\\n']\n"
     ]
    }
   ],
   "source": [
    "f = open('data.txt','r') # sai zoado pq tem que codificar direito\n",
    "lines = f.readlines()\n",
    "print(lines)\n",
    "\n",
    "# for l in f:\n",
    "#     print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Magic function que roda tudo que estÃ¡ na cÃ©lula\n",
      "\n",
      "# o comando acima envia o conteÃºdo desta cÃ©lula para\n",
      "\n",
      "# um arquivo texto chamado 'data.txt'\n",
      "\n",
      "\n",
      "\n",
      "hello world\n",
      "\n",
      "today is Wednesday\n",
      "\n",
      "winter is comming\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('data.txt', 'r') as f:  # garante que o arquivo será fechado corretamente quando finalizado. O with otimiza se o arquivo sera jogado para arquivo ou vai ficar no buffer. Jogar toda hora no disco rigido é muito caro\n",
    "    for line in f:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### write\n",
    "```python\n",
    "f.write()\n",
    "```\n",
    "escreve um string no arquivo\n",
    "```python\n",
    "f.writelines()\n",
    "```\n",
    "escreve uma lista de strings no arquivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('data2write.txt', 'w')\n",
    "lst = ['hello world\\n','today is Saturday\\n', \n",
    "       'winter is comming\\n'] #garante que ele vai pular de linha\n",
    "for i in lst:\n",
    "    f.write(i)\n",
    "\n",
    "f.close() # this is mandatory to flush data to disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = ['hello world\\n','today is Saturday\\n', \n",
    "       'winter is comming\\n']\n",
    "with open('data2write.txt', 'w') as f:\n",
    "    f.writelines(lst)"
   ]
  },
  {
   "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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}