prof_02_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Índice\n",
    "\n",
    "* Instalação do Ambiente\n",
    "* Interpretador\n",
    "* Variáveis\n",
    "* Tipos e Estruturas de Dados\n",
    "* Classes e Objetos\n",
    "* Funções\n",
    "* Estruturas de Controle de Fluxo\n",
    "* Módulos e Pacotes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Instalação do ambiente\n",
    "\n",
    "Para este curso utilizaremos o Anaconda, uma distribuição python que possui um gerenciamento de bibliotecas simples de utilizar e já traz pré-instaladas diversas bibliotecas que são de uso comum em ciência de dados.\n",
    "\n",
    "Para baixar o Anaconda e instalar em casa acesse: https://www.anaconda.com/download/\n",
    "\n",
    "O Anaconda possui uma opção para instalação somente para o usuário atual. É importante utilizar este modo de instalação pois com ele não há necessidade de provilégios de administrador na máquina."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Interpretador\n",
    "\n",
    "Python é uma linguagem interpretada, ou seja, o códgo fonte é lido e executado por um programa que, dinamicamente avalia as instruções e realiza as operações. Este programa é o interpretador da linguagem.\n",
    "\n",
    "O interpretador pode ser acionado de algumas formas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* python\n",
    "\n",
    "> Shell (interpretador de comandos) padrão do python\n",
    "\n",
    "![Prompt](imagens/prompt.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* python scripts\n",
    "\n",
    "> Arquivos de texto com a extensão .py que contém uma sequência de comandos python\n",
    "\n",
    "* ipython\n",
    "\n",
    "> Shell interativo do python com muitas funcionalidades e melhorias\n",
    "\n",
    "* Jupyter Notebook / Jupyter Lab\n",
    "\n",
    ">Permite trabalhar com o ipython através de um browser. \n",
    "```bash\n",
    "<caminho_para_anaconda>\\Scripts\\jupyter-notebook.exe\n",
    "ou\n",
    "<caminho_para_anaconda>\\Scripts\\jupyter-lab.exe\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Variáveis\n",
    "\n",
    "* Servem para armazenar tipos e estruturas de dados\n",
    "* Possuem algumas regras para formação do nome\n",
    "    * não pode começar com um número\n",
    "    * não pode ser uma das palavras reservadas da linguagem: 'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'. Na dúvida utilize o comando abaixo para imprimir a lista:\n",
    "```python\n",
    "import keyword\n",
    "print(keyword.kwlist)\n",
    "```\n",
    "\n",
    "* A atribução de valores é feita com o uso de um símbolo de igual (=)\n",
    "```python\n",
    "a = 10\n",
    "b = 20\n",
    "c = a + b\n",
    "d = 'atribuiçao de um texto'\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "c = a+b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tipos e Estruturas de Dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tipos Numéricos\n",
    "\n",
    "### Inteiros\n",
    "Utiliza-se a classe __int__ para representar números inteiros;\n",
    ">```python\n",
    ">int(3.2) # 3 \n",
    ">int(10)  # 10\n",
    ">int('5') # 5 \n",
    ">```\n",
    "\n",
    "### Decimais\n",
    "Utiliza-se a classe __float__ para representar números decimais (números com ponto flutuante);\n",
    ">```python\n",
    ">float(3.2) # 3.2 \n",
    ">float(10)  # 10.0\n",
    ">float('5') # 5.0\n",
    ">```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5200.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('5200.0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Principais operações suportadas pelos tipos numéricos:\n",
    "\n",
    "* __x + y__: soma de x e y\n",
    "* __x - y__: subtração de x e y\n",
    "* __x * y__: produto de x e y\n",
    "* __x / y__: quociente de x e y\n",
    "* __x // y__: divisão inteira de x e y\n",
    "* __x % y__: resto da divisão de x e y\n",
    "* __x ** y__: x elevado na potência y ( $x^y$ )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Exercício 01\n",
    "\n",
    "Atribua os valores 10 e 3 às variáveis x e y, respectivamente. Execute todas as operações acima e imprima o resultado para cada uma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "7\n",
      "30\n",
      "3.3333333333333335\n",
      "3\n",
      "1\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 3\n",
    "\n",
    "print(x+y)\n",
    "print(x-y)\n",
    "print(x*y)\n",
    "print(x/y)\n",
    "print(x//y)\n",
    "print(x%y)\n",
    "print(x**y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tipos Sequenciais\n",
    "\n",
    "### Listas\n",
    "\n",
    "Listas, ou objetos do tipo __list__, são utilizados para representar sequências ordenadas de itens. O conjunto sequencial de dados é rapidamente acessível através de índices.\n",
    "\n",
    "Alguns exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# declaração de uma lista vazia\n",
    "\n",
    "lista_vazia = list()\n",
    "\n",
    "lista_vazia = []\n",
    "\n",
    "# lista de compras\n",
    "lista_de_compras = ['maçã', 'banana', 'laranja']\n",
    "\n",
    "# aposta na mega sena\n",
    "aposta_mega_sena = [6, 14, 19, 20, 39, 53]\n",
    "\n",
    "# busca o segundo item da lista de compras\n",
    "# índices começam em 0\n",
    "segundo_item = lista_de_compras[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'banana'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segundo_item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### List Compreensions\n",
    "\n",
    "É uma forma de criação de listas à partir de outros tipos sequenciais. É possível iterar uma lista, tupla, string ou dicionário de maneira que se possa gerar uma nova lista com informações derivadas de alguma forma da lista original.\n",
    "\n",
    "Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "lista_quadrado = [x**2 for x in lista]\n",
    "print(lista_quadrado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Algumas operações comuns com listas:\n",
    "\n",
    "* __x in v__: se o item x está na lista v retorna True, senão False\n",
    "* __x not in v__: se o item x está na lista v retorna False, senão True\n",
    "* __t + v__: concatena as lista t e v\n",
    "* __v[i]__: retorna o valor na posição i da lista v (o índice começa em 0)\n",
    "* __v[i:j]__: retorna uma sublista da posição i até a j (não inclui a posição j)\n",
    "* __len(v)__: retorna o número de elementos da lista v\n",
    "* __min(v)__: retorna o menor elemeto da lista v\n",
    "* __max(v)__: retorna o maior elemeto da lista v\n",
    "* __sorted(v)__: retorna a lista v ordernada em ordem crescente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Operações que modificam a lista original:\n",
    "\n",
    "* __v.append(x)__: adiciona o elemento x ao final da lista v\n",
    "* __v.extend(t)__: adiciona a lista de elementos t ao final da lista v\n",
    "* __v.insert(i, x)__: adiciona o elemento x na posição i da lista v (o índice começa em 0)\n",
    "* __v.remove(x)__: remove o primeiro item com o valor x\n",
    "* __v.pop(i)__: se i for informado, remove o elemento da posição i da lista v e retorna o elemento. Se i não for informado, retorna o último elemento e o remove da lista\n",
    "* __v.sort()__: orderna a lista em ordem crescente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Índices e Slices (fatias)\n",
    "\n",
    "Índice | 0  | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 \n",
    " --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- \n",
    "Elemento da Lista | 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 | 100\n",
    "Índice Reverso | -10  | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "numeros = [10,20,30,40,50,60,70,80,90,100]\n",
    "# primeira posição\n",
    "print(numeros[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "# última posição\n",
    "print(numeros[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50, 60]\n"
     ]
    }
   ],
   "source": [
    "# posições 4 e 5\n",
    "print(numeros[4:6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[90, 100]\n"
     ]
    }
   ],
   "source": [
    "print(numeros[-2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "print(numeros[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercício 02\n",
    "\n",
    "Considere a lista de números a seguir: 2, 5, 1, 13, 9, 16.\n",
    "\n",
    "1. Crie uma lista contendo os números acima e atribua à variável 'sorteio' e imprima o conteúdo da variável;\n",
    "2. Ordene o conteúdo da variável, atribua o resultado à variável 'sorteio_ordenado'. O valor da variável sorteio não deve ser alterado. Imprima o conteúdo da variável sorteio_ordenado.\n",
    "3. Imprima os 3 maiores números da lista.\n",
    "4. Imprima os valores sorteados em ordem inversa (Dica: help(sorted) )\n",
    "5. Gere uma lista com os números da lista sorteio ao quadrado\n",
    "6. Calcule a soma dos números da lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 1, 13, 9, 16]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorteio = [2, 5, 1, 13, 9, 16]\n",
    "sorteio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorteio_ordenado = sorted(sorteio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 5]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorteio_ordenado[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sorted in module builtins:\n",
      "\n",
      "sorted(iterable, /, *, key=None, reverse=False)\n",
      "    Return a new list containing all items from the iterable in ascending order.\n",
      "    \n",
      "    A custom key function can be supplied to customize the sort order, and the\n",
      "    reverse flag can be set to request the result in descending order.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[16, 13, 9, 5, 2, 1]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(sorteio, reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 25, 1, 169, 81, 256]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x**2  for x in sorteio]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calcule a soma dos números da lista\n",
    "sum(sorteio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tuplas\n",
    "\n",
    "Tuplas, ou objetos do tipo __tuple__, são muito similares às listas, porém são imutáveis, ou seja, possuem as mesmas operações, exceto aquelas que realizam modificações no seu conteúdo.\n",
    "\n",
    "Alguns exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "lista_vazia = ()\n",
    "\n",
    "# nome, idade, sexo\n",
    "informacoes_pessoais = ('João', 26, 'M')\n",
    "\n",
    "# 1ª dezena sorteada, 2ª, 3ª, 4ª, 5ª, 6ª\n",
    "sorteio = (39, 6, 14, 20, 53, 19)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Para saber mais sobre listas e tuplas acesse:\n",
    "https://docs.python.org/3/tutorial/datastructures.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Ranges\n",
    "\n",
    "Utilizados para gerar sequências de números. São utilizados muitas vezes em comandos de loop.\n",
    "\n",
    "Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# lista de 0 a 9\n",
    "l = list(range(10)) # equivalente a range(stop=10)\n",
    "print(l)\n",
    "\n",
    "# lista de 2 a 20 com incremento de 2\n",
    "l = list(range(2, 21, 2)) # equivalente a range(start=10,stop=10,step=10)\n",
    "print(l)\n",
    "\n",
    "#\n",
    "for i in range(0, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Mais informações em https://docs.python.org/3/library/stdtypes.html#ranges."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings\n",
    "\n",
    "Uma sequência de caracteres em python é representada utilizando objetos do tipo __str__.\n",
    "Strings são __imutáveis__, uma vez criadas não podem ser modificadas. Possuem muitas caraterísticas das listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "olá\n",
      "teste\n",
      "\n",
      "João\n"
     ]
    }
   ],
   "source": [
    "# criação de strings\n",
    "string_vazia = str('')\n",
    "string_vazia = '' # aspas simples\n",
    "string_vazia = \"\" # aspas duplas\n",
    "string_vazia = '''olá''' # aspas simples triplas\n",
    "string_vazia = \"\"\"\n",
    "olá\n",
    "teste\n",
    "\"\"\" # aspas simples triplas\n",
    "print(string_vazia)\n",
    "nome = 'João'\n",
    "print(nome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primeira linha\n",
      "Segunda Linha\n"
     ]
    }
   ],
   "source": [
    "# quebra de linha\n",
    "quebra_de_linha = 'Primeira linha\\nSegunda Linha'\n",
    "print(quebra_de_linha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Texto longo que pode ter muitas linhas.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#blocos de texto em mais de uma linha\n",
    "bloco_de_texto = '''\n",
    "Texto longo que pode ter \\\n",
    "muitas linhas.\n",
    "'''\n",
    "print(bloco_de_texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "João Silva\n"
     ]
    }
   ],
   "source": [
    "# concatenar strings\n",
    "nome = 'João'\n",
    "sobrenome = 'Silva'\n",
    "\n",
    "nome_completo = nome + ' ' + sobrenome\n",
    "print(nome_completo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de caracteres:  10\n"
     ]
    }
   ],
   "source": [
    "# número de caracteres de uma string\n",
    "print('Número de caracteres: ', len(nome_completo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# testar se uma string está contida dentro de outra\n",
    "print(nome in nome_completo)\n",
    "print(nome in sobrenome)\n",
    "print(nome not in sobrenome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['João', 'Silva']\n",
      "['J', 'ã', ' Silva']\n"
     ]
    }
   ],
   "source": [
    "# quebrar uma string em várias à partir de um caractere\n",
    "print(nome_completo.split(' '))\n",
    "print(nome_completo.split('o'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string com\n",
      " algumas linhas\n",
      " para teste\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('string com', ' algumas linhas', ' para teste')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "teste = 'string com\\n algumas linhas\\n para teste'\n",
    "print(teste)\n",
    "tuple(teste.split('\\n'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Teste.txt', 'r', encoding='latin1') as file:\n",
    "    texto_arquivo = file.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Autopsicografia', '', 'O poeta é um fingidor.', 'Finge tão completamente', 'Que chega a fingir que é dor', 'A dor que deveras sente.', '', 'E os que leem o que escreve,', 'Na dor lida sentem bem,', 'Não as duas que ele teve,', 'Mas só a que eles não têm.', '', 'E assim nas calhas de roda', 'Gira, a entreter a razão,', 'Esse comboio de corda', 'Que se chama coração.']\n"
     ]
    }
   ],
   "source": [
    "print(texto_arquivo.split('\\n'))\n",
    "texto_arquivo_split = texto_arquivo.split('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maçã, Banana, Melão\n",
      "Autopsicografia  O poeta é um fingidor. Finge tão completamente Que chega a fingir que é dor A dor que deveras sente.  E os que leem o que escreve, Na dor lida sentem bem, Não as duas que ele teve, Mas só a que eles não têm.  E assim nas calhas de roda Gira, a entreter a razão, Esse comboio de corda Que se chama coração.\n"
     ]
    }
   ],
   "source": [
    "# concatenar uma lista de strings em uma string única\n",
    "lista = ['Maçã', 'Banana', 'Melão']\n",
    "print(', '.join(lista))\n",
    "print(' '.join(texto_arquivo_split))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Slices (fatias)\n",
    "\n",
    "Índice | 0  | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 \n",
    " --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- \n",
    "String | J | o | ã | o | &nbsp; | S | i | l | v | a \n",
    "Índice Reverso | -10  | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "J\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "# primeira letra\n",
    "print( nome_completo[0] )\n",
    "\n",
    "# última letra\n",
    "print( nome_completo[-1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "João\n",
      "Silva\n"
     ]
    }
   ],
   "source": [
    "# Primeira Palavra\n",
    "print( nome_completo[0:4] )\n",
    "\n",
    "# Última Palavra\n",
    "print( nome_completo[5:] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Formatação de Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "um dois\n",
      "3.14\n",
      "007\n",
      "10xx\n"
     ]
    }
   ],
   "source": [
    "# Inclusão de variáveis\n",
    "print('{} {}'.format('um', 'dois'))\n",
    "\n",
    "# Formatação de números\n",
    "print('{:.2f}'.format(3.1415926))\n",
    "\n",
    "# Completar com zeros à esquerda\n",
    "print('{:0>3d}'.format(7))\n",
    "\n",
    "# Completar com x à direita\n",
    "print('{:x<4d}'.format(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cpfs = [123451, 123222451, 12223451, 1123451]\n",
    "cpf = 123451"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cpfs_tratados = ['{:0>11d}'.format(x) for x in lista_cpfs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00000123451, 00123222451, 00012223451, 00001123451'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "', '.join(lista_cpfs_tratados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00000123451, 00123222451, 00012223451, 00001123451\n"
     ]
    }
   ],
   "source": [
    "print(', '.join(['{:0>11d}'.format(x) for x in lista_cpfs]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Mais detalhes sobre opções de formatação podem ser encontradas em https://docs.python.org/3.7/library/string.html#format-specification-mini-language"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Outras funções: \n",
    "```python\n",
    "s.startswith(prefx[,start[,end]])\n",
    "s.endswith(sufx[,start[,end]]) \n",
    "s.strip([chars])\n",
    "s.count(sub[,start[,end]])\n",
    "s.index(sub[,start[,end]]) \n",
    "s.find(sub[,start[,end]])\n",
    "s.is…() ex. s.isalpha()\n",
    "s.upper() \n",
    "s.lower() \n",
    "s.capitalize() \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "#### #python\n",
    "* no python 3 toda string é unicode (UTF8). Se quiser entender mais sobre encodings e representações de strings no python acesse [Unicode HOWTO](https://docs.python.org/3/howto/unicode.html);\n",
    "* o encoding padrão para o código fonte também é UTF8, entretanto, pode ser alterado utilizando a seguinte diretiva no ínicio do arquivo:\n",
    "> ```python\n",
    "> # -*- coding: <encoding name> -*-\n",
    "> ```\n",
    "* mais informações sobre strings em python acesse https://docs.python.org/3.6/library/string.html\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercício 3\n",
    "\n",
    "Para a resolução dos exercícios a seguir, utilize o conteúdo da variável texto.\n",
    "\n",
    "Dica: \n",
    "```\n",
    "lista = [1, 2, 3]\n",
    "[ x for x in lista if x >= 2 ]\n",
    "```\n",
    "\n",
    "1. Escreva um código que calcula o tamanho da string contida na variável texto;\n",
    "2. Escreva um código que calcula o número de linhas contidas na variável texto utilizada no exercício 2. Para isso:\n",
    "    * faça o uso da função split, utilizando o caracter '\\n' como parâmetro;\n",
    "    * o retorno da função split é uma lista de strings. Conte o número de elementos da lista para saber quantas linhas existem;\n",
    "3. Escreva um código que retorna apenas as últimas 4 linhas do poema contido na variável 'texto' utilizada no exercício 2;\n",
    "4. Escreva um código que lista as linhas que contém a substring 'dor'.\n",
    "5. Escreva um código que lista as linhas que contém a palavra 'dor'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "texto = '''\\\n",
    "Autopsicografia\n",
    "\n",
    "O poeta é um fingidor.\n",
    "Finge tão completamente\n",
    "Que chega a fingir que é dor\n",
    "A dor que deveras sente.\n",
    "\n",
    "E os que leem o que escreve,\n",
    "Na dor lida sentem bem,\n",
    "Não as duas que ele teve,\n",
    "Mas só a que eles não têm.\n",
    "\n",
    "E assim nas calhas de roda\n",
    "Gira, a entreter a razão,\n",
    "Esse comboio de corda\n",
    "Que se chama coração.'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "322"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Escreva um código que calcula o tamanho da string contida na variável texto;\n",
    "len(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Escreva um código que calcula o número de linhas \n",
    "# contidas na variável texto utilizada no exercício\n",
    "linhas_texto = texto.split('\\n')\n",
    "len(linhas_texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['E assim nas calhas de roda',\n",
       " 'Gira, a entreter a razão,',\n",
       " 'Esse comboio de corda',\n",
       " 'Que se chama coração.']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Escreva um código que retorna apenas as últimas 4 \n",
    "# linhas do poema contido na variável 'texto' utilizada no exercício 2;\n",
    "linhas_texto[-4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Autopsicografia', '', 'O poeta é um fingidor.', 'Finge tão completamente']"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linhas_texto[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AUTOPSICOGRAFIA',\n",
       " '',\n",
       " 'O POETA É UM FINGIDOR.',\n",
       " 'FINGE TÃO COMPLETAMENTE',\n",
       " 'QUE CHEGA A FINGIR QUE É DOR',\n",
       " 'A DOR QUE DEVERAS SENTE.',\n",
       " '',\n",
       " 'E OS QUE LEEM O QUE ESCREVE,',\n",
       " 'NA DOR LIDA SENTEM BEM,',\n",
       " 'NÃO AS DUAS QUE ELE TEVE,',\n",
       " 'MAS SÓ A QUE ELES NÃO TÊM.',\n",
       " '',\n",
       " 'E ASSIM NAS CALHAS DE RODA',\n",
       " 'GIRA, A ENTRETER A RAZÃO,',\n",
       " 'ESSE COMBOIO DE CORDA',\n",
       " 'QUE SE CHAMA CORAÇÃO.']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x.upper() for x in linhas_texto]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['O poeta é um fingidor.',\n",
       " 'Que chega a fingir que é dor',\n",
       " 'A dor que deveras sente.',\n",
       " 'Na dor lida sentem bem,']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Escreva um código que lista as linhas que contém a substring 'dor'.\n",
    "[x for x in linhas_texto if 'dor' in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Escreva um código que lista as linhas que contém a palavra 'dor'.\n",
    "texto = '''\\\n",
    "Autopsicografia\n",
    "\n",
    "O poeta é um fingidor.\n",
    "Finge tão completamente\n",
    "Que chega a fingir que é dor!\n",
    "A Dor? que deveras sente.\n",
    "\n",
    "E os que leem o que escreve,\n",
    "Na dor lida sentem bem,\n",
    "Não as duas que ele teve,\n",
    "Mas só a que eles não têm.\n",
    "\n",
    "E assim nas calhas de roda\n",
    "Gira, a entreter a razão,\n",
    "Esse comboio de corda\n",
    "Que se chama coração.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Que chega a fingir que é dor!',\n",
       " 'A Dor? que deveras sente.',\n",
       " 'Na dor lida sentem bem,']"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in texto.split('\\n') if re.search(r'\\bdor\\b',x, re.I) ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Dicionários\n",
    "\n",
    "Dicionários são estrutras que armazenam uma coleção de objetos. Utilizam um par chave e valor ao invés de índices. Cada chave deve ser única."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O abacaxi (Ananas comosus), em Portugal também conhecido como ananás, é uma ...\n"
     ]
    }
   ],
   "source": [
    "# criação de um dicionário vazio\n",
    "dicionario_vazio = {}\n",
    "dicionario_vazio = dict()\n",
    "\n",
    "frutas = {\n",
    "    'Abacaxi': 'O abacaxi (Ananas comosus), em Portugal também conhecido como ananás, é uma ...',\n",
    "    'Melancia': 'Melancia (Citrullus lanatus) é o nome de uma planta da família Cucurbitacea ...',\n",
    "}\n",
    "\n",
    "print(frutas['Abacaxi'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Abacaxi': 'O abacaxi (Ananas comosus), em Portugal também conhecido como ananás, é uma ...', 'Melancia': 'Melancia (Citrullus lanatus) é o nome de uma planta da família Cucurbitacea ...', 'Banana': 'Banana, pacoba ou pacova[1] é uma pseudobaga da bananeira, uma planta herbá ...'}\n"
     ]
    }
   ],
   "source": [
    "# incluir uma nova entrada no dicionário\n",
    "frutas['Banana'] = 'Banana, pacoba ou pacova[1] é uma pseudobaga da bananeira, uma planta herbá ...'\n",
    "print(frutas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Abacaxi', 'Melancia', 'Banana'])\n"
     ]
    }
   ],
   "source": [
    "# listar todas as chaves do dicionario\n",
    "print(frutas.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Abacaxi': 'O abacaxi (Ananas comosus), em Portugal também conhecido como ananás, é uma ...',\n",
       " 'Banana': 'Banana, pacoba ou pacova[1] é uma pseudobaga da bananeira, uma planta herbá ...'}"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# remover um item\n",
    "del(frutas['Melancia'])\n",
    "frutas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# como saber se uma chave existe em um dicionário?\n",
    "print( 'Melancia' in frutas )\n",
    "print( 'Banana' in frutas )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Abacaxi', 'Banana'])\n"
     ]
    }
   ],
   "source": [
    "# listar todas as chaves do dicionario\n",
    "print(frutas.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Dictionary Compreensions\n",
    "\n",
    "Também é possível gerar dicionários utilizando a mesma sintaxe de list compreensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Quadrado de 0': 0, 'Quadrado de 1': 1, 'Quadrado de 2': 4, 'Quadrado de 3': 9, 'Quadrado de 4': 16, 'Quadrado de 5': 25, 'Quadrado de 6': 36, 'Quadrado de 7': 49, 'Quadrado de 8': 64, 'Quadrado de 9': 81}\n"
     ]
    }
   ],
   "source": [
    "lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "lista_quadrado = {'Quadrado de {}'.format(x): x**2 for x in lista}\n",
    "print(lista_quadrado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sets\n",
    "São similares a dicionários mas possuem apenas a chave e não preservam elementos repetidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# criação de um set vazio\n",
    "s = set()\n",
    "\n",
    "# criacao de um set com elementos\n",
    "s = {1,2,3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# transformando uma lista em um set\n",
    "s = set([1,2,3,4,4,5,6,2])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operações de conjuntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# UNIÃO\n",
    "{1,2,3,4} | {3, 4,5,6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# INTERSECÇÃO\n",
    "{1,2,3,4} & {3, 4,5,6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# DIFERENÇA\n",
    "{1,2,3,4} - {3, 4,5,6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = set([1,2,3])\n",
    "1 in a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Booleanos\n",
    "\n",
    "O tipo booleano é representado pela classe __bool__. Ele representa 2 estados: verdadeiro (True) e falso (False). Todas as expressões de comparação e lógica utilizam esse tipo de dado. No python, porém, qualquer objeto da linguagem pode ser avaliado em um valor lógico. Vejamos abaixo:\n",
    "\n",
    "* Constantes e objetos avaliados como falso:\n",
    "    * False, None;\n",
    "    * tipos numéricos com valor '0': 0, 0.0;\n",
    "    * coleções e tipos sequenciais vazios: '', ( ), \\[ \\], { }, set( ), range(0)\n",
    "\n",
    "* Constantes e objetos avaliados como verdadeiro:\n",
    "    * True;\n",
    "    * quaisquer objetos que não estão enquadrados nos critérios de falso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Principais operações booleanas:\n",
    "* __x or y__: se x é falso retorna y, senão retorna x\n",
    "* __x and y__: se x é falso retorna x, senão retorna y\n",
    "* __not x__: se x é falso, retorna True, senão retorna False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```\n",
    "T or T => T            T and T => T            not T => F\n",
    "T or F => T            T and F => F            not F => T\n",
    "F or T => T            F and T => F\n",
    "F or F => F            F and F => F\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "É possível realizar operações aritméticas sobre booleanos, que nesse caso são tratados como False:0 e True:1; Assim, sum(boolean_variables) dá o número de valores verdadeiros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_booleanos = [False, False, True, False]\n",
    "sum(lista_booleanos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes e Objetos\n",
    "\n",
    "__Classe__ é a definição de uma estrutura que pode ter estados e que pode possuir ações que modificam este estado. Estados são representados por __atributos__ e ações são representadas por __métodos__.\n",
    "__Objeto__ é a instância de uma classe. É a materialização de uma classe que à partir desse momento possui seus próprios atributos.\n",
    "\n",
    "Como saber mais informações sobre um determinado objeto?\n",
    "\n",
    "* __type()__: identifica o tipo de um objeto\n",
    "* __dir()__: lista atributos e métodos disponíveis em um objeto\n",
    "* __help()__: mostra a documentação do python para um objeto, atributo, método ou função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__',\n",
       " '__add__',\n",
       " '__bool__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getformat__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__int__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__round__',\n",
       " '__rpow__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__set_format__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__truediv__',\n",
       " '__trunc__',\n",
       " 'as_integer_ratio',\n",
       " 'conjugate',\n",
       " 'fromhex',\n",
       " 'hex',\n",
       " 'imag',\n",
       " 'is_integer',\n",
       " 'real']"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1 * 1.1\n",
    "dir(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "#### #python\n",
    "\n",
    "* Para aprofundar-se mais nos conceitos de Classes e Objetos é interessante ler o capítulo de classes na documentação do python: https://docs.python.org/3.6/tutorial/classes.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funções\n",
    "Funções são blocos de execução de código. Permitem a reutilização de rotinas comuns e também a generalização das rotinas com a utlização de __parâmetros__ que podem ser passados para a função."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function teste in module __main__:\n",
      "\n",
      "teste()\n",
      "    Função de teste que nao faz nada. Mas está documentada.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# criaçao de uma função\n",
    "def teste():\n",
    "    \"\"\"\n",
    "    Função de teste que nao faz nada. Mas está documentada.\n",
    "    \"\"\"\n",
    "    print('Executando a função teste')\n",
    "\n",
    "# chamada da função\n",
    "help(teste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Banana, pacoba ou pacova[1] é uma pseudobaga da bananeira, uma planta herbácea vivaz acaule da família Musaceae (género Musa - além do género Ensete, que produz as chamadas \"falsas bananas\"). São cultivadas em 130 países. Originárias do sudeste da Ásia são atualmente cultivadas em praticamente todas as regiões tropicais do planeta.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "from lxml import etree\n",
    "from urllib.parse import quote\n",
    "from lxml.etree import tostring\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "def busca_definicao_wikipedia(palavra):\n",
    "    \"\"\"\n",
    "    Busca o primeiro parágrafo de um verbete da Wikipedia.\n",
    "    \n",
    "    Acessa a url https://pt.wikipedia.org/wiki/palavra, busca o conteúdo do primeiro\n",
    "    parágrafo utilizando xpath e retorna o conteúdo sem tags html.\n",
    "    \n",
    "    :param palavra (str): Verbete que será pesquisado\n",
    "    :returns (str): Retorna o primeiro parágrafo do verbete ou None se ocorrer algum erro ou o verbete não existir.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        url =  \"https://pt.wikipedia.org/wiki/{}\"\n",
    "        url = url.format(quote(palavra))\n",
    "        response = requests.get(url, verify=False)\n",
    "        htmlparser = etree.HTMLParser()\n",
    "        tree = etree.fromstring(response.text, htmlparser)\n",
    "        # //*[@id=\"mw-content-text\"]/div\n",
    "        elemento = tree.xpath('//*[@id=\"mw-content-text\"]/div/p')[0]\n",
    "        return ''.join(elemento.itertext())\n",
    "    except:\n",
    "        return None\n",
    "\n",
    "print(busca_definicao_wikipedia('Banana'))\n",
    "# print(busca_definicao_wikipedia(palavra='Melancia'))\n",
    "# print(busca_definicao_wikipedia(palavra='Barão de Mauá'))\n",
    "# print(busca_definicao_wikipedia(palavra='Fernando Pessoa'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Em python existem 2 parâmetros especiais que podem ser definidos nas funções. Servem para funções que necessitam receber parâmetros dinamicamente. São úteis quando o número de parâmetros não é conhecido ou o nome do parâmetro não é preestabelecido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "('p1',)\n",
      "{'d': 4, 'valor': 10, 'string': 'teste'}\n"
     ]
    }
   ],
   "source": [
    "def teste(a, b=3, *args, **kwargs):\n",
    "    print(a)\n",
    "    print(b)\n",
    "    print(args)\n",
    "    print(kwargs)\n",
    "\n",
    "teste(2, 4, 'p1', d=4, valor=10, string='teste')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funções lambda\n",
    "\n",
    "Em python, expressão lambda é uma sintaxe especial para a criação de funções anônimas.\n",
    "São utilizadas, geralmente, em casos onde se quer definir uma função que será utilizada apenas uma vez para algum propósito.\n",
    "\n",
    "Expressões lambda permitem que este código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "estados = ['Acre - AC', 'Alagoas - AL', 'Amazonas - AM']\n",
    "\n",
    "def encontrar_siglas(estado):\n",
    "    return estado.split('-')[1].strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AC'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Acre - AC'.split('-')[1].strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AC', 'AL', 'AM']"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "siglas = [encontrar_siglas(x) for x in estados]\n",
    "list(siglas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AC', 'AL', 'AM']"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "siglas = map(encontrar_siglas, estados)\n",
    "list(siglas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Seja escrito desta forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AC', 'AL', 'AM']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estados = ['Acre - AC', 'Alagoas - AL', 'Amazonas - AM']\n",
    "siglas = map(lambda estado: estado.split('-')[1].strip(), estados)\n",
    "list(siglas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Escopos\n",
    "Não vamos falar detalhadamente sobre escopos mas entenda este exemplo básico:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escopo Teste\n",
      "2\n",
      "5\n",
      "Escopo Global\n",
      "5\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-125-a07132c56ffc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Escopo Global\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "del(a)\n",
    "b = 4\n",
    "\n",
    "def teste():\n",
    "    a = 2\n",
    "    global b\n",
    "    b = 5\n",
    "    print(\"Escopo Teste\")\n",
    "    print(a)\n",
    "    print(b)\n",
    "    \n",
    "teste()\n",
    "\n",
    "print(\"Escopo Global\")\n",
    "print(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Estruturas de Controle de Fluxo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### if\n",
    "\n",
    "É utilizado para a execuçao de blocos de código em determinadas condições."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "\n",
    "if a == 1:\n",
    "    # comando 1\n",
    "    # comando 2\n",
    "    # comando n\n",
    "    print()\n",
    "elif b == 3:\n",
    "    # comando 1\n",
    "    # comando 2\n",
    "    # comando n\n",
    "    print()\n",
    "else:\n",
    "    # comando 1\n",
    "    # comando 2\n",
    "    # comando n\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### for\n",
    "\n",
    "Utilizado para iterar estruturas de dados sequenciais como list, string, tuple ou range. Permitem a execução de blocos de código a cada iteração."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maçã\n",
      "banana\n",
      "mamão\n"
     ]
    }
   ],
   "source": [
    "lista_de_compras = ['maçã', 'banana', 'mamão']\n",
    "for item in lista_de_compras:\n",
    "    # comando 1\n",
    "    # comando 2\n",
    "    # comando n\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 - maçã\n",
      "1 - banana\n",
      "2 - mamão\n"
     ]
    }
   ],
   "source": [
    "for indice, item in enumerate(lista_de_compras):\n",
    "    # comando 1\n",
    "    # comando 2\n",
    "    # comando n\n",
    "    print(indice, '-', item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = (0, 'maçã')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "maçã\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 maçã\n",
      "1 banana\n",
      "2 laranja\n"
     ]
    }
   ],
   "source": [
    "for indice, valor in enumerate(lista_de_compras):\n",
    "    print(indice, valor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "laranja\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, len(lista_de_compras)):\n",
    "    print(lista_de_compras[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Juntamente com o for é comum o uso de Generators. A função enumerate utilizada acima é um exemplo de generator. São funções especiais que são avaliadas durante um loop e geram seu conteúdo a cada iteração. Dessa forma é possivel reduzir o uso de memória ao trabalhar com grandes volumes de dados. Para saber mais leia (https://docs.python.org/3/howto/functional.html#generators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### while\n",
    "\n",
    "Utilizado para realizar iterações até que determinas condições sejam atingidas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A contagem é 0 !\n",
      "A contagem é 1 !\n",
      "A contagem é 2 !\n",
      "A contagem é 3 !\n",
      "A contagem é 4 !\n",
      "Até mais!\n"
     ]
    }
   ],
   "source": [
    "contador = 0\n",
    "\n",
    "while contador <= 4:\n",
    "    print('A contagem é',contador,'!')\n",
    "    contador += 1\n",
    "    \n",
    "print('Até mais!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercício 4\n",
    "\n",
    "1. Escreva um código que conta quantas vezes cada caractere aparece no poema contido na variável 'texto' utilizada no exercício 3.\n",
    "2. Evolua o código do item anterior, de forma que maiúsculas ou minúculas sejam contabilizadas juntas;\n",
    "3. Evolua o código do item anterior, de forma que caracteres acentuados sejam contabilizados juntamente com os seus respectivos caracteres sem acento.\n",
    "4. Transforme o código do item anterior em uma função que recebe um parâmetro \"texto\" e retorna um dicionário com a contagem de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Autopsicografia\\n\\nO poeta é um fingidor.\\nFinge tão completamente\\nQue chega a fingir que é dor!\\nA Dor? que deveras sente.\\n\\nE os que leem o que escreve,\\nNa dor lida sentem bem,\\nNão as duas que ele teve,\\nMas só a que eles não têm.\\n\\nE assim nas calhas de roda\\nGira, a entreter a razão,\\nEsse comboio de corda\\nQue se chama coração.'"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'\\n',\n",
       " ' ',\n",
       " '!',\n",
       " ',',\n",
       " '.',\n",
       " '?',\n",
       " 'A',\n",
       " 'D',\n",
       " 'E',\n",
       " 'F',\n",
       " 'G',\n",
       " 'M',\n",
       " 'N',\n",
       " 'O',\n",
       " 'Q',\n",
       " 'a',\n",
       " 'b',\n",
       " 'c',\n",
       " 'd',\n",
       " 'e',\n",
       " 'f',\n",
       " 'g',\n",
       " 'h',\n",
       " 'i',\n",
       " 'l',\n",
       " 'm',\n",
       " 'n',\n",
       " 'o',\n",
       " 'p',\n",
       " 'q',\n",
       " 'r',\n",
       " 's',\n",
       " 't',\n",
       " 'u',\n",
       " 'v',\n",
       " 'z',\n",
       " 'ã',\n",
       " 'ç',\n",
       " 'é',\n",
       " 'ê',\n",
       " 'ó'}"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'l': 6,\n",
       " '?': 1,\n",
       " ' ': 52,\n",
       " 'ó': 1,\n",
       " 'n': 9,\n",
       " 'é': 2,\n",
       " 's': 18,\n",
       " 'M': 1,\n",
       " 'Q': 2,\n",
       " 'm': 10,\n",
       " 'D': 1,\n",
       " '\\n': 15,\n",
       " 'h': 3,\n",
       " 'F': 1,\n",
       " 'c': 9,\n",
       " 'u': 11,\n",
       " 'a': 26,\n",
       " 'p': 3,\n",
       " 'r': 15,\n",
       " 'd': 10,\n",
       " 'f': 3,\n",
       " 'v': 3,\n",
       " 'O': 1,\n",
       " '!': 1,\n",
       " 'o': 21,\n",
       " 'E': 3,\n",
       " 'z': 1,\n",
       " 'b': 2,\n",
       " 'N': 2,\n",
       " 'G': 1,\n",
       " 'q': 6,\n",
       " 'ç': 1,\n",
       " 't': 11,\n",
       " 'i': 11,\n",
       " 'e': 39,\n",
       " 'A': 2,\n",
       " 'ê': 1,\n",
       " '.': 4,\n",
       " ',': 5,\n",
       " 'ã': 5,\n",
       " 'g': 5}"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Escreva um código que conta quantas vezes cada caractere \n",
    "# aparece no poema contido na variável 'texto' utilizada no exercício 3.\n",
    "{c: texto.count(c) for c in set(texto) }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto.count('E')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(texto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'l': 6,\n",
       " '?': 1,\n",
       " ' ': 52,\n",
       " 'ó': 1,\n",
       " 'n': 9,\n",
       " 'é': 2,\n",
       " 's': 18,\n",
       " 'M': 1,\n",
       " 'Q': 2,\n",
       " 'm': 10,\n",
       " 'D': 1,\n",
       " '\\n': 15,\n",
       " 'h': 3,\n",
       " 'F': 1,\n",
       " 'c': 9,\n",
       " 'u': 11,\n",
       " 'a': 26,\n",
       " 'p': 3,\n",
       " 'r': 15,\n",
       " 'd': 10,\n",
       " 'f': 3,\n",
       " 'v': 3,\n",
       " 'O': 1,\n",
       " '!': 1,\n",
       " 'o': 21,\n",
       " 'E': 3,\n",
       " 'z': 1,\n",
       " 'b': 2,\n",
       " 'N': 2,\n",
       " 'G': 1,\n",
       " 'q': 6,\n",
       " 'ç': 1,\n",
       " 't': 11,\n",
       " 'i': 11,\n",
       " 'e': 39,\n",
       " 'A': 2,\n",
       " 'ê': 1,\n",
       " '.': 4,\n",
       " ',': 5,\n",
       " 'ã': 5,\n",
       " 'g': 5}"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# {c: texto.count(c) for c in set(texto) }\n",
    "contagem = {}\n",
    "caracteres_nao_duplicados = set(texto)\n",
    "for c in caracteres_nao_duplicados:\n",
    "    contagem[c] = texto.count(c)\n",
    "\n",
    "contagem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contagem = {}\n",
    "caracteres_nao_duplicados = set(texto)\n",
    "for c in caracteres_nao_duplicados:\n",
    "    contagem[c] = texto.count(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1}"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 'a'\n",
    "{c: 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{c: texto.count(c) for c in set(texto)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'\\n': 15,\n",
       " ' ': 52,\n",
       " '!': 1,\n",
       " ',': 5,\n",
       " '.': 4,\n",
       " '?': 1,\n",
       " 'A': 28,\n",
       " 'B': 2,\n",
       " 'C': 9,\n",
       " 'D': 11,\n",
       " 'E': 42,\n",
       " 'F': 4,\n",
       " 'G': 6,\n",
       " 'H': 3,\n",
       " 'I': 11,\n",
       " 'L': 6,\n",
       " 'M': 11,\n",
       " 'N': 11,\n",
       " 'O': 22,\n",
       " 'P': 3,\n",
       " 'Q': 8,\n",
       " 'R': 15,\n",
       " 'S': 18,\n",
       " 'T': 11,\n",
       " 'U': 11,\n",
       " 'V': 3,\n",
       " 'Z': 1,\n",
       " 'Ã': 5,\n",
       " 'Ç': 1,\n",
       " 'É': 2,\n",
       " 'Ê': 1,\n",
       " 'Ó': 1}"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evolua o código do item anterior, de forma que maiúsculas ou minúculas sejam contabilizadas juntas;\n",
    "texto_upper = texto.upper()\n",
    "{c: texto_upper.count(c) for c in sorted(set(texto_upper)) }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'\\n': 15,\n",
       " ' ': 52,\n",
       " '!': 1,\n",
       " ',': 5,\n",
       " '.': 4,\n",
       " '?': 1,\n",
       " 'A': 33,\n",
       " 'B': 2,\n",
       " 'C': 10,\n",
       " 'D': 11,\n",
       " 'E': 45,\n",
       " 'F': 4,\n",
       " 'G': 6,\n",
       " 'H': 3,\n",
       " 'I': 11,\n",
       " 'L': 6,\n",
       " 'M': 11,\n",
       " 'N': 11,\n",
       " 'O': 23,\n",
       " 'P': 3,\n",
       " 'Q': 8,\n",
       " 'R': 15,\n",
       " 'S': 18,\n",
       " 'T': 11,\n",
       " 'U': 11,\n",
       " 'V': 3,\n",
       " 'Z': 1}"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evolua o código do item anterior, de forma que caracteres acentuados sejam contabilizados juntamente com os seus respectivos caracteres sem acento.\n",
    "\n",
    "from libs.texto import TratamentoTexto\n",
    "\n",
    "texto_sem_acentos = TratamentoTexto.remover_acentuacao(texto)\n",
    "texto_upper = texto_sem_acentos.upper()\n",
    "{c: texto_upper.count(c) for c in sorted(set(texto_upper)) }\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'\\n': 15,\n",
       " ' ': 52,\n",
       " '!': 1,\n",
       " ',': 5,\n",
       " '.': 4,\n",
       " '?': 1,\n",
       " 'A': 33,\n",
       " 'B': 2,\n",
       " 'C': 10,\n",
       " 'D': 11,\n",
       " 'E': 45,\n",
       " 'F': 4,\n",
       " 'G': 6,\n",
       " 'H': 3,\n",
       " 'I': 11,\n",
       " 'L': 6,\n",
       " 'M': 11,\n",
       " 'N': 11,\n",
       " 'O': 23,\n",
       " 'P': 3,\n",
       " 'Q': 8,\n",
       " 'R': 15,\n",
       " 'S': 18,\n",
       " 'T': 11,\n",
       " 'U': 11,\n",
       " 'V': 3,\n",
       " 'Z': 1}"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transforme o código do item anterior em uma função que recebe um parâmetro \"texto\" e retorna um dicionário com a contagem de caracteres.\n",
    "from libs.texto import TratamentoTexto\n",
    "\n",
    "def contar_caracteres(t):\n",
    "    texto_sem_acentos = TratamentoTexto.remover_acentuacao(t)\n",
    "    texto_upper = texto_sem_acentos.upper()\n",
    "    return {c: texto_upper.count(c) for c in sorted(set(texto_upper)) }\n",
    "\n",
    "contar_caracteres(texto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Módulos e Pacotes\n",
    "\n",
    "__Módulos__ são arquivos com extensão \".py\" que definem classes e/ou funções com o objetivo de reutilizá-los.\n",
    "\n",
    "__Pacotes__ são diretórios contendo um ou mais módulos. São utilizados para organização dos módulos.\n",
    "\n",
    "Para utilizar módulos e pacotes precisamos da declaração __import__.\n",
    "\n",
    "Exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.getwindowsversion(major=10, minor=0, build=16299, platform=2, service_pack='')\n"
     ]
    }
   ],
   "source": [
    "# importação de um módulo\n",
    "import sys\n",
    "print(sys.getwindowsversion())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\visit.814300000\\Documents\\iadp20190812\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-08-13\n"
     ]
    }
   ],
   "source": [
    "# importação de um módulo que está dentro de um pacote\n",
    "from datetime import date\n",
    "print(date.today())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "import libs.texto as libtexto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "libtexto.TratamentoTexto.remover_acentuacao('á')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import libs.texto\n",
    "libs.texto.TratamentoTexto.remover_acentuacao('á')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from libs.texto import TratamentoTexto\n",
    "TratamentoTexto.remover_acentuacao('á')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Existe uma biblioteca padrão, composta por diversos pacotes, que vem junto com o interpretador python. Diversas funcionalidades importantes estão disponíveis mas precisam ser importadas como nos casos acima.\n",
    "\n",
    "Existem, ainda, diversas bibliotecas que não estão instaladas por padrão, mas podem ser instaladas utilizando um instalador de pacotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Instaladores de Pacotes\n",
    "\n",
    "É muito comum necessitarmos de pacotes disponibilizados pela comunidade para podermos utilizar reaproveitar funcionalidades muitos utilizadas e testadas. Para termos acesso a estes pacotes, a maneira mais simples é utilizando um instalador de pacotes.\n",
    "\n",
    "O instalador de pacotes padrão do python é o __pip__. Entretanto, a distribuição Anaconda possui um instalador próprio que no ambiente windows possui muitas vantagens em relação ao pip. Esse instalador é o __conda__.\n",
    "\n",
    "Assim, sempre tentaremos primeiro fazer qualquer instalação utilizando o __conda__, caso o pacote não esteja disponível em nenhum canal, utilizamos o __pip__.\n",
    "\n",
    "Ambos podem ser executados através de um comando de terminal ou através de script python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Abaixo vemos a sintaxe para execução de ambos através de terminal:\n",
    "\n",
    "Conda\n",
    "```shell\n",
    "conda list <nome_do_pacote>     # pesquisa pacotes disponíveis de acordo com o nome informado\n",
    "conda install <nome_do_pacote>  # instala um pacote\n",
    "```\n",
    "\n",
    "Pip\n",
    "```shell\n",
    "pip search <nome_do_pacote>           # pesquisa pacotes disponíveis de acordo com o nome informado\n",
    "pip install <nome_do_pacote> [--user] # instala um pacote\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pandas in c:\\programdata\\anaconda3\\lib\\site-packages (0.23.4)\n",
      "Requirement already satisfied: python-dateutil>=2.5.0 in c:\\programdata\\anaconda3\\lib\\site-packages (from pandas) (2.7.5)\n",
      "Requirement already satisfied: pytz>=2011k in c:\\programdata\\anaconda3\\lib\\site-packages (from pandas) (2018.7)\n",
      "Requirement already satisfied: numpy>=1.9.0 in c:\\programdata\\anaconda3\\lib\\site-packages (from pandas) (1.15.4)\n",
      "Requirement already satisfied: six>=1.5 in c:\\programdata\\anaconda3\\lib\\site-packages (from python-dateutil>=2.5.0->pandas) (1.12.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " O volume na unidade C ‚ Disco Local\n",
      " O N£mero de S‚rie do Volume ‚ B4A9-2AE2\n",
      "\n",
      " Pasta de C:\\Users\\visit.814300000\\Documents\\iadp20190812\n",
      "\n",
      "13/08/2019  09:36    <DIR>          .\n",
      "13/08/2019  09:36    <DIR>          ..\n",
      "12/08/2019  08:51             1.203 .gitignore\n",
      "12/08/2019  11:08    <DIR>          .ipynb_checkpoints\n",
      "12/08/2019  09:53         1.939.594 01_introducao.ipynb\n",
      "13/08/2019  09:36            93.441 02_python.ipynb\n",
      "12/08/2019  08:51            18.545 03_python_basico_exercicios_comentados.ipynb\n",
      "12/08/2019  08:51            34.833 04_pandas_series.ipynb\n",
      "12/08/2019  08:51            11.428 05_pandas_exercicios_series.ipynb\n",
      "12/08/2019  08:51           144.840 06_pandas_dataframe.ipynb\n",
      "12/08/2019  08:51            15.913 07_pandas_exercicios_dataframe.ipynb\n",
      "12/08/2019  08:51            63.742 08_passagens_aereas_apf.ipynb\n",
      "12/08/2019  08:51             4.411 09_organizacao_dados.ipynb\n",
      "12/08/2019  08:51            15.088 10_visualizacao_dados.ipynb\n",
      "12/08/2019  08:51    <DIR>          dados\n",
      "12/08/2019  08:51    <DIR>          docs\n",
      "12/08/2019  08:51    <DIR>          imagens\n",
      "12/08/2019  17:31    <DIR>          libs\n",
      "12/08/2019  08:51             1.078 LICENSE\n",
      "12/08/2019  08:51         1.939.594 prof_01_introducao.ipynb\n",
      "12/08/2019  08:51           109.046 prof_02_python.ipynb\n",
      "12/08/2019  08:51            47.557 prof_04_pandas_series.ipynb\n",
      "12/08/2019  08:51            15.099 prof_05_pandas_exercicios_series.ipynb\n",
      "12/08/2019  08:51           251.232 prof_06_pandas_dataframe.ipynb\n",
      "12/08/2019  08:51           160.602 prof_07_pandas_exercicios_dataframe.ipynb\n",
      "12/08/2019  08:51           461.273 prof_08_passagens_aereas_apf.ipynb\n",
      "12/08/2019  08:51             4.411 prof_09_organizacao_dados.ipynb\n",
      "12/08/2019  08:51         1.696.468 prof_10_visualizacao_dados.ipynb\n",
      "12/08/2019  08:51                60 README.md\n",
      "12/08/2019  08:51             1.114 requirements.txt\n",
      "12/08/2019  11:06                37 teste.py\n",
      "12/08/2019  14:23               337 Teste.txt\n",
      "12/08/2019  11:14             1.355 Untitled.ipynb\n",
      "              26 arquivo(s)      7.032.301 bytes\n",
      "               7 pasta(s)   104.001.519.616 bytes dispon¡veis\n"
     ]
    }
   ],
   "source": [
    "!dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "#### #python\n",
    "\n",
    " * mais informações sobre os comandos do conda: https://conda.io/docs/commands.html\n",
    " * mais informações sobre os comandos do pip: https://pip.pypa.io/en/stable/reference/ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Alguns pacotes que utilizaremos neste curso:\n",
    "\n",
    "#### math\n",
    "\n",
    "Conjunto de funções matemáticas disponibilizadas pela biblioteca padrão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# algumas funções de exemplo\n",
    "math.ceil(1.01)     # 2\n",
    "math.floor(1.01)    # 1\n",
    "math.sqrt(100)      # 10\n",
    "math.trunc(1.999)   # returns 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Mais informações em https://docs.python.org/3.6/library/math.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### datetime\n",
    "\n",
    "O pacote __datetime__ é um pacote da biblioteca padrão da linguagem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'21/02/2014 23h50m'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime as dt\n",
    "data_informada = dt.strptime('2014 02 21  23:50:09','%Y %m %d %H:%M:%S')\n",
    "dt.strftime(data_informada,'%d/%m/%Y %Hh%Mm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Para referência completa de parsing, formatação e operações com datas veja: https://docs.python.org/3.6/library/datetime.html#strftime-strptime-behavior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### babel\n",
    "\n",
    "Um pacote que fornece vários utilitários para trabalhar com internacionalização em python. Utilizaremos para conversão de moedas e datas de formatos diversos para o formato brasileiro."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### NumPy e SciPy\n",
    "\n",
    "São pacotes que fornecem estruturas de dados e funções avançadas para processamento científico em python. Em geral, o numpy concentra as estruturas de dados e algumas operações de álgebra linear. Já o scipy possui suporte para matrizes esparsas e possuir uma série de módulos mais avançados para algebra linear, transformadas de fourier, estatística entre outras funcionalidades. Em geral, ambos são instalados para processamento científico.\n",
    "\n",
    "As estruturas de dados definidas nestes pacotes são a base para o funcionamento do pandas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "#### #python\n",
    "* mais detalhes sobre módulos em python https://docs.python.org/3/tutorial/modules.html\n",
    "* mais detales sobre o funcionamento do mecanismo de importação https://docs.python.org/3/reference/import.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercício 5\n",
    "\n",
    "Escreva um código que lista todos os arquivos do diretorio onde \n",
    "este caderno está executando (ignore os diretórios).\n",
    "\n",
    "Dicas:\n",
    "* importe a biblioteca 'os', ela contém várias funções úteis relacionadas ao sistema operacional;\n",
    "* utilize os.getcwd() para buscar o caminho onde este jupyter está executando\n",
    "* utilize os.walk(caminho) para listar os arquivos\n",
    "* Procure no google exemplos de uso destas funções para entender melhor como elas funcionam\n",
    "* utilize o help do python para ver a documentação delas;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\visit.814300000\\Documents\\iadp20190812\n",
      "['.ipynb_checkpoints', 'dados', 'docs', 'imagens', 'libs']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['01_introducao.ipynb',\n",
       " '02_python.ipynb',\n",
       " '03_python_basico_exercicios_comentados.ipynb',\n",
       " '04_pandas_series.ipynb',\n",
       " '05_pandas_exercicios_series.ipynb',\n",
       " '06_pandas_dataframe.ipynb',\n",
       " '07_pandas_exercicios_dataframe.ipynb',\n",
       " '08_passagens_aereas_apf.ipynb',\n",
       " '09_organizacao_dados.ipynb',\n",
       " '10_visualizacao_dados.ipynb']"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "import re\n",
    "\n",
    "cadernos_de_aula = []\n",
    "for root, dirs, files in os.walk(os.getcwd()):\n",
    "    print(root)\n",
    "    print(dirs)\n",
    "    cadernos_de_aula = [f for f in files \n",
    "                        if re.search(r'^\\d{2}_.*[.]ipynb', f, re.I)]\n",
    "    dirs.clear()\n",
    "\n",
    "cadernos_de_aula\n",
    "#     if 'CVS' in dirs:\n",
    "#         dirs.remove('CVS')  # don't visit CVS directories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercício 6\n",
    "\n",
    "Dicas:\n",
    "* importe a biblioteca 'datetime', ela contém várias funções e classes úteis para trabalhar com datas em python\n",
    "\n",
    "\n",
    "1. Escreva um código que retorna um objeto datetime com a data e hora atuais.\n",
    "\n",
    "2. Escreva um código que retorna um objeto date com a data atual.\n",
    "\n",
    "3. Escreva um código que retorna um objeto time somente com a hora atual.\n",
    "\n",
    "4. Escreva um código que retorna a data e hora do sistema e imprime no formato brasileiro.\n",
    "    * utilize a máscara '%d/%m/%Y %H:%M:%S'\n",
    "    * utilize a função datetime.strftime() (https://docs.python.org/3.6/library/datetime.html#strftime-strptime-behavior)\n",
    "\n",
    "5. Escreva um código que transforma uma string com data e hora no formato brasileiro para um objeto datetime.\n",
    "    * utilize a máscara '%d/%m/%Y %H:%M:%S'\n",
    "    * utilize a função datetime.strptime() (https://docs.python.org/3.6/library/datetime.html#strftime-strptime-behavior)\n",
    "    \n",
    "6. Calcule o número de dias entre duas datas\n",
    "    * pesquise sobre timedelta (https://docs.python.org/3.6/library/datetime.html#datetime.timedelta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(datetime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2019, 8, 13, 11, 42, 4, 805010)"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agora = datetime.datetime.now()\n",
    "agora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date(2019, 8, 13)"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hoje = datetime.date.today()\n",
    "hoje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.time(11, 46, 19, 397228)"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hora = datetime.datetime.now().time()\n",
    "hora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2019, 8, 13, 11, 42, 4, 805010)"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agora.str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'13/08/2019 11:42:04'"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agora.strftime('%d/%m/%Y %H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2019, 8, 13, 11, 42, 4)"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.strptime('13/08/2019 11:42:04', '%d/%m/%Y %H:%M:%S')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = datetime.datetime(2018, 10, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2 = datetime.datetime(2019, 5, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "212"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "td = d2 - d1\n",
    "td.days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104 days, 11:42:04.805010\n"
     ]
    }
   ],
   "source": [
    "print(agora - d2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ola repr"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Teste:\n",
    "    def __repr__(self):\n",
    "        return 'ola repr'\n",
    "\n",
    "    def __str__(self):\n",
    "        return 'ola str'\n",
    "t = Teste()        \n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ola str\n"
     ]
    }
   ],
   "source": [
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercício 7\n",
    "\n",
    "Instale a biblioteca babel.\n",
    "Abra o prompt da anaconda ( Menu Iniciar -> Anaconda3 -> Anaconda Prompt ) e digite:\n",
    "```shell\n",
    "pip install babel --user\n",
    "```\n",
    "\n",
    "Faça um restart no kernel do Jupyter para garantir que ele reconheça a nova biblioteca.\n",
    "\n",
    "1. Utilize a função format_decimal do módulo numbers da biblioteca babel (pacote) para formatar o float 1250.2345 para o formato moeda no padrão brasileiro. Utilize o locale pt_BR.\n",
    "\n",
    "2. Utilize a função parse_decimal do módulo numbers da biblioteca babel (pacote) para converter a string '-1.250,23' para o formato float do python. Utilize o locale pt_BR."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: babel in c:\\programdata\\anaconda3\\lib\\site-packages (2.6.0)\n",
      "Requirement already satisfied: pytz>=0a in c:\\programdata\\anaconda3\\lib\\site-packages (from babel) (2018.7)\n"
     ]
    }
   ],
   "source": [
    "!pip install babel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "function loadScript(url, callback){\n",
       "    var script = document.createElement(\"script\")\n",
       "    script.type = \"text/javascript\";\n",
       "\n",
       "    if (script.readyState){  //IE\n",
       "        script.onreadystatechange = function(){\n",
       "            if (script.readyState == \"loaded\" ||\n",
       "                    script.readyState == \"complete\"){\n",
       "                script.onreadystatechange = null;\n",
       "                callback();\n",
       "            }\n",
       "        };\n",
       "    } else {  //Others\n",
       "        script.onload = function(){\n",
       "            callback();\n",
       "        };\n",
       "    }\n",
       "\n",
       "    script.src = url;\n",
       "    document.getElementsByTagName(\"head\")[0].appendChild(script);\n",
       "}\n",
       "\n",
       "//loadScript('https://code.jquery.com/jquery-3.3.1.slim.min.js', function(){console.log(1123)});\n",
       "//funciona para Jupyter Notebook\n",
       "//$('.input').css('display', 'none');\n",
       "//funciona para Jupyter Lab\n",
       "//$('.jp-Cell-inputWrapper').css('display', 'block');\n",
       ";\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "\n",
    "function loadScript(url, callback){\n",
    "    var script = document.createElement(\"script\")\n",
    "    script.type = \"text/javascript\";\n",
    "\n",
    "    if (script.readyState){  //IE\n",
    "        script.onreadystatechange = function(){\n",
    "            if (script.readyState == \"loaded\" ||\n",
    "                    script.readyState == \"complete\"){\n",
    "                script.onreadystatechange = null;\n",
    "                callback();\n",
    "            }\n",
    "        };\n",
    "    } else {  //Others\n",
    "        script.onload = function(){\n",
    "            callback();\n",
    "        };\n",
    "    }\n",
    "\n",
    "    script.src = url;\n",
    "    document.getElementsByTagName(\"head\")[0].appendChild(script);\n",
    "}\n",
    "\n",
    "//loadScript('https://code.jquery.com/jquery-3.3.1.slim.min.js', function(){console.log(1123)});\n",
    "//funciona para Jupyter Notebook\n",
    "//$('.input').css('display', 'none');\n",
    "//funciona para Jupyter Lab\n",
    "//$('.jp-Cell-inputWrapper').css('display', 'block');\n",
    ";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "(function() {var css = [\n",
       "    //\"body {\",\n",
       "    //\"    font-family: serif;\",\n",
       "    //\"}\",\n",
       "    \".container {\",\n",
       "    \"    width: 100%;\",\n",
       "    \"}\",\n",
       "    \".text_cell_render table {\",\n",
       "    \"    font-size: 24;\",\n",
       "    \"}\",\n",
       "    \".rendered_html code {\",\n",
       "    \"    background-color: #fafafa; \",\n",
       "    \"}\",\n",
       "    \".rendered_html :not(pre) > code {\",\n",
       "    \"    padding: 1px 1px;\",\n",
       "    \"}\",\n",
       "    \".rendered_html pre code {\",\n",
       "    \"    background-color: #fafafa;\",\n",
       "    \"}\",\n",
       "    \".rendered_html pre {\",\n",
       "    \"    border: 1px;\",\n",
       "    \"    background-color: #fafafa;\",\n",
       "    \"    padding: .5ex .5em;\",\n",
       "    \"}\"\n",
       "].join(\"\\n\");\n",
       "if (typeof GM_addStyle != \"undefined\") {\n",
       "    GM_addStyle(css);\n",
       "} else if (typeof PRO_addStyle != \"undefined\") {\n",
       "    PRO_addStyle(css);\n",
       "} else if (typeof addStyle != \"undefined\") {\n",
       "    addStyle(css);\n",
       "} else {\n",
       "    var node = document.createElement(\"style\");\n",
       "    node.type = \"text/css\";\n",
       "    node.appendChild(document.createTextNode(css));\n",
       "    var heads = document.getElementsByTagName(\"head\");\n",
       "    if (heads.length > 0) {\n",
       "        heads[0].appendChild(node);\n",
       "    } else {\n",
       "        // no head yet, stick it whereever\n",
       "        document.documentElement.appendChild(node);\n",
       "    }\n",
       "}\n",
       "})();\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "\n",
    "(function() {var css = [\n",
    "    //\"body {\",\n",
    "    //\"    font-family: serif;\",\n",
    "    //\"}\",\n",
    "    \".container {\",\n",
    "    \"    width: 100%;\",\n",
    "    \"}\",\n",
    "    \".text_cell_render table {\",\n",
    "    \"    font-size: 24;\",\n",
    "    \"}\",\n",
    "    \".rendered_html code {\",\n",
    "    \"    background-color: #fafafa; \",\n",
    "    \"}\",\n",
    "    \".rendered_html :not(pre) > code {\",\n",
    "    \"    padding: 1px 1px;\",\n",
    "    \"}\",\n",
    "    \".rendered_html pre code {\",\n",
    "    \"    background-color: #fafafa;\",\n",
    "    \"}\",\n",
    "    \".rendered_html pre {\",\n",
    "    \"    border: 1px;\",\n",
    "    \"    background-color: #fafafa;\",\n",
    "    \"    padding: .5ex .5em;\",\n",
    "    \"}\"\n",
    "].join(\"\\n\");\n",
    "if (typeof GM_addStyle != \"undefined\") {\n",
    "    GM_addStyle(css);\n",
    "} else if (typeof PRO_addStyle != \"undefined\") {\n",
    "    PRO_addStyle(css);\n",
    "} else if (typeof addStyle != \"undefined\") {\n",
    "    addStyle(css);\n",
    "} else {\n",
    "    var node = document.createElement(\"style\");\n",
    "    node.type = \"text/css\";\n",
    "    node.appendChild(document.createTextNode(css));\n",
    "    var heads = document.getElementsByTagName(\"head\");\n",
    "    if (heads.length > 0) {\n",
    "        heads[0].appendChild(node);\n",
    "    } else {\n",
    "        // no head yet, stick it whereever\n",
    "        document.documentElement.appendChild(node);\n",
    "    }\n",
    "}\n",
    "})();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "___\n",
    "__Material produzido para o curso__:\n",
    "* Introdução à Análise de Dados com Python\n",
    "\n",
    "__Autor__:\n",
    "* Fernando Sola Pereira\n",
    "\n",
    "__Revisão__:\n",
    "* 1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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"
  },
  "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
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}