Aula_1_corr.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: latin1 -*-\n",
    "# Uma linha quebrada por contra-barra\n",
    "a = 7 * 3 + \\\n",
    "5 / 2\n",
    "# Uma lista (quebrada por vírgula)\n",
    "b = ['a', 'b', 'c',\n",
    "'d', 'e']\n",
    "# Uma chamada de função (quebrada por vírgula)\n",
    "c = range(1,\n",
    "11)\n",
    "# imprime todos na tela\n",
    "print a, b, c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### O erro ocorreu devido à diferença de versões do python. Criamos um código na versão 2 e executamos na versão 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uma linha quebrada por contra-barra\n",
    "a = 7 * 3 + \\\n",
    "5 / 2\n",
    "# Uma lista (quebrada por vírgula)\n",
    "b = ['a', 'b', 'c',\n",
    "'d', 'e']\n",
    "d = [1,2,3,4,\n",
    "    5,6,7]\n",
    "# Uma chamada de função (quebrada por vírgula)\n",
    "c = range(1,\n",
    "11)\n",
    "# imprime todos na tela\n",
    "print (a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comentários"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# comentário em apenas uma linha\n",
    "# para cada linha preciso adicionar o identificador de comentário\n",
    "\n",
    "\"\"\"\n",
    "Este é um exemplo de bloco de comentário\n",
    "Comentário em mais de uma linha\n",
    "É mais usado para Docstrings: documentação e teste do código em python\n",
    "\n",
    "Para saber mais, acesse: https://www.python.org/dev/peps/pep-0257/\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Endentação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para i na lista 234, 654, 378, 798:\n",
    "for i in [234, 654, 378, 798]:\n",
    "# Se o resto da divisão por 3 for igual a zero:\n",
    "    if i % 3 == 0:\n",
    "    # Imprime...\n",
    "        print (i, '/ 3 =', i / 3)\n",
    "    if i % 2 == 0:\n",
    "        print('algma coisa')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Atributos e Métodos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.arange(10) \n",
    "y = x.sum() #método\n",
    "\n",
    "x.argmax() # atributo - retorna o índice do maior valor no vetor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Controle de Fluxo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp = int(input('Entre com a temperatura: '))\n",
    "if temp < 0:\n",
    "    print ('Congelando...')\n",
    "elif (0 <= temp <= 20):\n",
    "    print ('Frio')\n",
    "elif (21 <= temp <= 25):\n",
    "    print ('Normal')\n",
    "elif (26 <= temp <= 35):\n",
    "    print ('Quente')\n",
    "else:\n",
    "    print ('Muito quente!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'verdadeiro' if 1>0 else 'falso'\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Laços"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# usando for\n",
    "s = 0\n",
    "for x in range(1, 100):\n",
    "    s = s + x\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1,2,3,4\n",
    "s = 0,1,3,6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# usando while\n",
    "s = 0\n",
    "x = 1\n",
    "while x < 100:\n",
    "    s = s + x\n",
    "    x = x + 1\n",
    "print (s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Break, Continue e Pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parada = 10\n",
    "inicio = 0\n",
    "\n",
    "while parada > 0:\n",
    "    print(parada)\n",
    "    parada -= 1\n",
    "    if parada == 3:\n",
    "        break\n",
    "    elif parada ==4:\n",
    "        print('Volta pro inicio')\n",
    "        continue\n",
    "    else:\n",
    "        print('passou')\n",
    "        pass\n",
    "else:\n",
    "    print(\"final\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO Section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.23, 2.12, 4.99, 5.09, 3.57]\n"
     ]
    }
   ],
   "source": [
    "some_list = [1.2345, 2.1234, 4.9876, 5.0912, 3.5687]\n",
    "\n",
    "# TODO: utilizando a mesma variável, ajuste cada número para que este contenha apenas 2 números após a casa decimal\n",
    "# Dica: https://docs.python.org/3/library/functions.html#round\n",
    "\n",
    "for i in range(len(some_list)):\n",
    "    some_list[i] = round(some_list[i],2)\n",
    "print(some_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número par encontrado:  2\n",
      "Número par encontrado:  4\n",
      "Número par encontrado:  6\n",
      "Número par encontrado:  8\n",
      "Número par encontrado:  10\n",
      "Número 12 encontrado\n"
     ]
    }
   ],
   "source": [
    "# TODO: O laço a seguir percorre uma lista do número 2 até o número 15. \n",
    "# Toda vez que um número par for encontrado, faça: print (\"Número par encontrado: \", num) e vá para o início do laço\n",
    "# Ao encontrar o número 12, faça: print (\"Número 12 encontrado\"), e encerre o programa\n",
    "\n",
    "for num in range(2,15):\n",
    "    if (num == 12):\n",
    "        print(\"Número 12 encontrado\")\n",
    "        break\n",
    "    if (num % 2 == 0):\n",
    "        print(\"Número par encontrado: \",num)\n",
    "        continue\n",
    "else:\n",
    "    print(\"Numero 12 não encontrado\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos de Dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int(3.14) = 3\n",
      "float(5) = 5.0\n",
      "5.0 / 2 + 3 =  5.5\n",
      "5/4 ou 5.0/4.0 =  1\n",
      "c = (4+3j)\n",
      "Parte real: 4.0\n",
      "Parte imaginária: 3.0\n",
      "Conjugado: (4-3j)\n"
     ]
    }
   ],
   "source": [
    "print ('int(3.14) =', int(3.14)) # real para inteiro\n",
    "print ('float(5) =', float(5)) # inteiro para real\n",
    "print ('5.0 / 2 + 3 = ', 5.0 / 2 + 3) #Divisão que resulta em real\n",
    "print ('5/4 ou 5.0/4.0 = ',5//4) #divisão sem resto\n",
    "c = 4 + 3j #número complexo\n",
    "print ('c =', c)\n",
    "print ('Parte real:', c.real)\n",
    "print ('Parte imaginária:', c.imag)\n",
    "print ('Conjugado:', c.conjugate())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Camel run away!\n",
      "tamanho de Camel => 5\n",
      "C\n",
      "a\n",
      "m\n",
      "e\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "s = 'Camel'\n",
    "print ('The ' + s + ' run away!')\n",
    "print ('tamanho de %s => %d' % (s, len(s))) # interpolação\n",
    "for ch in s: print (ch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agora são 08:30.\n",
      "Percentagem: 5.3%, Exponencial:3.14e-03\n",
      "Decimal: 10, Octal: 12, Hexadecimal: a\n"
     ]
    }
   ],
   "source": [
    "print ('Agora são %02d:%02d.' % (8, 30))\n",
    "print ('Percentagem: %.1f%%, Exponencial:%.2e' % (5.333, 0.00314)) #casa decimal e formatação\n",
    "print ('Decimal: %d, Octal: %o, Hexadecimal: %x' % (10, 10, 10)) #bases numéricas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Page é guitarrista do Led Zeppelin\n",
      "<class 'str'>\n",
      "Fripp é guitarrista do King Crimson\n",
      "<class 'str'>\n",
      "x é y do z\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "musicos = [('Page', 'guitarrista', 'Led Zeppelin'),\n",
    "('Fripp', 'guitarrista', 'King Crimson'),\n",
    "('x','y','z')]\n",
    "\n",
    "msg = '{0} é {1} do {2}'\n",
    "\n",
    "for nome, funcao, banda in musicos:\n",
    "    x = msg.format(nome, funcao, banda)\n",
    "    print(msg.format(nome, funcao, banda))\n",
    "    print(type(x))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\some\n",
      "ame\n",
      "C:\\some\\name\n"
     ]
    }
   ],
   "source": [
    "# Caracteres antecipados por \\ são interpretados como caracteres especiais; \n",
    "# se você quer evitar isso, use raw strings, adicionando um r antes da primeira aspas\n",
    "\n",
    "print ('C:\\some\\name')\n",
    "print (r'C:\\some\\name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['string', 0.1, True]\n",
      "[[1, 2, 3], ['string', 0.1, True], []]\n"
     ]
    }
   ],
   "source": [
    "# listas são objetos heterogêneos, ou seja, \n",
    "# podem contem elementos de qualquer tipo,\n",
    "# inclusive outras listas\n",
    "\n",
    "integer_list = [1, 2, 3]\n",
    "heterogeneous_list = [\"string\", 0.1, True]\n",
    "list_of_lists = [ integer_list, heterogeneous_list, [] ]\n",
    "\n",
    "print(integer_list)\n",
    "print(heterogeneous_list)\n",
    "print(list_of_lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Queen\n",
      "Led Zeppelin\n",
      "Kansas\n",
      "Europe\n",
      "Guns N Roses\n",
      "['Bon Jovi', 'Guns N Roses', 'Kansas', 'Led Zeppelin', 'Queen']\n"
     ]
    }
   ],
   "source": [
    "bandas = ['Queen','Led Zeppelin','Kansas','Europe','Guns N Roses']\n",
    "\n",
    "for banda in bandas:\n",
    "    print (banda)\n",
    "    \n",
    "bandas.append('Bon Jovi') #adiciona ao fim da lista - inplace\n",
    "bandas.remove('Europe') #remove\n",
    "bandas.sort() #ordena\n",
    "\n",
    "print (bandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 => Bon Jovi\n",
      "2 => Guns N Roses\n",
      "3 => Kansas\n",
      "4 => Led Zeppelin\n",
      "5 => Queen\n",
      "Saiu Bon Jovi , faltam 4\n",
      "Saiu Guns N Roses , faltam 3\n",
      "Saiu Kansas , faltam 2\n",
      "Saiu Led Zeppelin , faltam 1\n",
      "Saiu Queen , faltam 0\n"
     ]
    }
   ],
   "source": [
    "for i, banda in enumerate(bandas): \n",
    "    print (i + 1, '=>', banda)\n",
    "    \n",
    "#filas e pilhas\n",
    "while bandas:\n",
    "    print ('Saiu', bandas.pop(0), ', faltam', len(bandas))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6, -1)\n",
      "15\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "def soma_e_produto(x, y):\n",
    "    return (x + y),(x * y), (x-y)\n",
    "sp = soma_e_produto(2, 3) # igual (5, 6)\n",
    "s, p, _ = soma_e_produto(5, 10) # s é 15, p é 50\n",
    "print(sp)\n",
    "print(s)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 6, -1)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dicionários"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mustang\n",
      "1964\n"
     ]
    }
   ],
   "source": [
    "carros = {'marca':'Ford','modelo':'Mustang','Ano':1964} #cria um dicionário\n",
    "print(carros['modelo']) #imprime o valor da chave 'modelo'\n",
    "print(carros.get('Ano')) #imprime usando método get\n",
    "carros['Ano'] = 2018"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "marca Ford\n",
      "modelo Mustang\n",
      "Ano 2018\n"
     ]
    }
   ],
   "source": [
    "for x,y in carros.items():#imprimindo keys e values\n",
    "    print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "marca Ford\n",
      "modelo Mustang\n",
      "Ano 2018\n",
      "cor preto\n"
     ]
    }
   ],
   "source": [
    "carros['cor'] = 'preto' #inserindo nova key e value\n",
    "\n",
    "for x,y in carros.items():#repetindo após inserção\n",
    "    print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'marca': 'Ford', 'modelo': 'Mustang', 'cor': 'preto'}\n"
     ]
    }
   ],
   "source": [
    "del carros['Ano'] #apagando key e value  - \n",
    "#pode ser usado os métodos pop e popitem - testar\n",
    "print (carros) #imprime dicionário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "#Apagar dicionário\n",
    "#del carros\n",
    "#print(carros)\n",
    "#esvaziar dicionário\n",
    "carros.clear()\n",
    "print(carros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'marca': ['Ford', 'FIAT', 'Wolksvagem'], 'modelo': ['Mustang', 'Palio', 'Gol'], 'Ano': [1964, 2009, 1990]}\n"
     ]
    }
   ],
   "source": [
    "#criando a partir de um construtor\n",
    "carros = dict(marca=['Ford','FIAT','Wolksvagem'],modelo=['Mustang','Palio','Gol'],Ano=[1964,2009,1990])\n",
    "print(carros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DefaultDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "document = 'A Wikipédia é um projeto de enciclopédia colaborativa, universal e multilíngue estabelecido na internet sob o princípio wiki. \\\n",
    "Tem como propósito fornecer um conteúdo livre, objetivo e verificável, que todos possam editar e melhorar. O projeto é definido pelos \\\n",
    "princípios fundadores. O conteúdo é disponibilizado sob a licença Creative Commons BY-SA e pode ser copiado e reutilizado sob a mesma \\\n",
    "licença — mesmo para fins comerciais — desde que respeitando os termos e condições de uso.'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_counts = {}\n",
    "for word in document.split(' '):\n",
    "    if word in word_counts:\n",
    "        word_counts[word] += 1\n",
    "    else:\n",
    "        word_counts[word] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1,\n",
       " 'Wikipédia': 1,\n",
       " 'é': 3,\n",
       " 'um': 2,\n",
       " 'projeto': 2,\n",
       " 'de': 2,\n",
       " 'enciclopédia': 1,\n",
       " 'colaborativa,': 1,\n",
       " 'universal': 1,\n",
       " 'e': 6,\n",
       " 'multilíngue': 1,\n",
       " 'estabelecido': 1,\n",
       " 'na': 1,\n",
       " 'internet': 1,\n",
       " 'sob': 3,\n",
       " 'o': 1,\n",
       " 'princípio': 1,\n",
       " 'wiki.': 1,\n",
       " 'Tem': 1,\n",
       " 'como': 1,\n",
       " 'propósito': 1,\n",
       " 'fornecer': 1,\n",
       " 'conteúdo': 2,\n",
       " 'livre,': 1,\n",
       " 'objetivo': 1,\n",
       " 'verificável,': 1,\n",
       " 'que': 2,\n",
       " 'todos': 1,\n",
       " 'possam': 1,\n",
       " 'editar': 1,\n",
       " 'melhorar.': 1,\n",
       " 'O': 2,\n",
       " 'definido': 1,\n",
       " 'pelos': 1,\n",
       " 'princípios': 1,\n",
       " 'fundadores.': 1,\n",
       " 'disponibilizado': 1,\n",
       " 'a': 2,\n",
       " 'licença': 2,\n",
       " 'Creative': 1,\n",
       " 'Commons': 1,\n",
       " 'BY-SA': 1,\n",
       " 'pode': 1,\n",
       " 'ser': 1,\n",
       " 'copiado': 1,\n",
       " 'reutilizado': 1,\n",
       " 'mesma': 1,\n",
       " '—': 2,\n",
       " 'mesmo': 1,\n",
       " 'para': 1,\n",
       " 'fins': 1,\n",
       " 'comerciais': 1,\n",
       " 'desde': 1,\n",
       " 'respeitando': 1,\n",
       " 'os': 1,\n",
       " 'termos': 1,\n",
       " 'condições': 1,\n",
       " 'uso.': 1}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "word_counts = defaultdict(int) # int() produces 0\n",
    "for word in document.split(' '):\n",
    "    word_counts[word] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int,\n",
       "            {'A': 1,\n",
       "             'Wikipédia': 1,\n",
       "             'é': 3,\n",
       "             'um': 2,\n",
       "             'projeto': 2,\n",
       "             'de': 2,\n",
       "             'enciclopédia': 1,\n",
       "             'colaborativa,': 1,\n",
       "             'universal': 1,\n",
       "             'e': 6,\n",
       "             'multilíngue': 1,\n",
       "             'estabelecido': 1,\n",
       "             'na': 1,\n",
       "             'internet': 1,\n",
       "             'sob': 3,\n",
       "             'o': 1,\n",
       "             'princípio': 1,\n",
       "             'wiki.': 1,\n",
       "             'Tem': 1,\n",
       "             'como': 1,\n",
       "             'propósito': 1,\n",
       "             'fornecer': 1,\n",
       "             'conteúdo': 2,\n",
       "             'livre,': 1,\n",
       "             'objetivo': 1,\n",
       "             'verificável,': 1,\n",
       "             'que': 2,\n",
       "             'todos': 1,\n",
       "             'possam': 1,\n",
       "             'editar': 1,\n",
       "             'melhorar.': 1,\n",
       "             'O': 2,\n",
       "             'definido': 1,\n",
       "             'pelos': 1,\n",
       "             'princípios': 1,\n",
       "             'fundadores.': 1,\n",
       "             'disponibilizado': 1,\n",
       "             'a': 2,\n",
       "             'licença': 2,\n",
       "             'Creative': 1,\n",
       "             'Commons': 1,\n",
       "             'BY-SA': 1,\n",
       "             'pode': 1,\n",
       "             'ser': 1,\n",
       "             'copiado': 1,\n",
       "             'reutilizado': 1,\n",
       "             'mesma': 1,\n",
       "             '—': 2,\n",
       "             'mesmo': 1,\n",
       "             'para': 1,\n",
       "             'fins': 1,\n",
       "             'comerciais': 1,\n",
       "             'desde': 1,\n",
       "             'respeitando': 1,\n",
       "             'os': 1,\n",
       "             'termos': 1,\n",
       "             'condições': 1,\n",
       "             'uso.': 1})"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({0: 2, 1: 1, 2: 1})"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "c = Counter([0, 1, 2, 0]) \n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'A': 1,\n",
       "         'Wikipédia': 1,\n",
       "         'é': 3,\n",
       "         'um': 2,\n",
       "         'projeto': 2,\n",
       "         'de': 2,\n",
       "         'enciclopédia': 1,\n",
       "         'colaborativa,': 1,\n",
       "         'universal': 1,\n",
       "         'e': 6,\n",
       "         'multilíngue': 1,\n",
       "         'estabelecido': 1,\n",
       "         'na': 1,\n",
       "         'internet': 1,\n",
       "         'sob': 3,\n",
       "         'o': 1,\n",
       "         'princípio': 1,\n",
       "         'wiki.': 1,\n",
       "         'Tem': 1,\n",
       "         'como': 1,\n",
       "         'propósito': 1,\n",
       "         'fornecer': 1,\n",
       "         'conteúdo': 2,\n",
       "         'livre,': 1,\n",
       "         'objetivo': 1,\n",
       "         'verificável,': 1,\n",
       "         'que': 2,\n",
       "         'todos': 1,\n",
       "         'possam': 1,\n",
       "         'editar': 1,\n",
       "         'melhorar.': 1,\n",
       "         'O': 2,\n",
       "         'definido': 1,\n",
       "         'pelos': 1,\n",
       "         'princípios': 1,\n",
       "         'fundadores.': 1,\n",
       "         'disponibilizado': 1,\n",
       "         'a': 2,\n",
       "         'licença': 2,\n",
       "         'Creative': 1,\n",
       "         'Commons': 1,\n",
       "         'BY-SA': 1,\n",
       "         'pode': 1,\n",
       "         'ser': 1,\n",
       "         'copiado': 1,\n",
       "         'reutilizado': 1,\n",
       "         'mesma': 1,\n",
       "         '—': 2,\n",
       "         'mesmo': 1,\n",
       "         'para': 1,\n",
       "         'fins': 1,\n",
       "         'comerciais': 1,\n",
       "         'desde': 1,\n",
       "         'respeitando': 1,\n",
       "         'os': 1,\n",
       "         'termos': 1,\n",
       "         'condições': 1,\n",
       "         'uso.': 1})"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_counts_counter = Counter(document.split(' '))\n",
    "word_counts_counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO Section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1)\n",
    "Escreva um programa que vá de 0 até 100. Toda vez que encontrar um número divisível por 5, \n",
    "adicione esse número numa lista. Ao final, ordene a lista de forma descendente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0]\n"
     ]
    }
   ],
   "source": [
    "# Resposta 1\n",
    "lista = []\n",
    "for i in range(0,100):\n",
    "    if i%5==0:\n",
    "        lista.append(i)\n",
    "print(sorted(lista,reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2)\n",
    "Conte a quantidade de cada caracter presente no texto abaixo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Texto\n",
    "\n",
    "Brasil, oficialmente República Federativa do Brasil é o maior país da América do Sul e da região da América Latina, sendo o quinto maior do mundo em área territorial (equivalente a 47 porcento do território sul-americano) e sexto em população (com mais de 200 milhões de habitantes). É o único país na América onde se fala majoritariamente a língua portuguesa e o maior país lusófono do planeta, além de ser uma das nações mais multiculturais e etnicamente diversas, em decorrência da forte imigração oriunda de variados locais do mundo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(' ', 88),\n",
       " ('a', 56),\n",
       " ('e', 43),\n",
       " ('o', 40),\n",
       " ('i', 38),\n",
       " ('r', 31),\n",
       " ('m', 24),\n",
       " ('d', 24),\n",
       " ('s', 23),\n",
       " ('n', 22),\n",
       " ('t', 22),\n",
       " ('l', 18),\n",
       " ('u', 16),\n",
       " ('c', 14),\n",
       " ('p', 9),\n",
       " ('é', 5),\n",
       " (',', 4),\n",
       " ('f', 4),\n",
       " ('v', 4),\n",
       " ('í', 4),\n",
       " ('g', 4),\n",
       " ('A', 3),\n",
       " ('ã', 3),\n",
       " ('ç', 3),\n",
       " ('B', 2),\n",
       " ('ú', 2),\n",
       " ('b', 2),\n",
       " ('q', 2),\n",
       " ('(', 2),\n",
       " ('ó', 2),\n",
       " (')', 2),\n",
       " ('0', 2),\n",
       " ('h', 2),\n",
       " ('õ', 2),\n",
       " ('.', 2),\n",
       " ('R', 1),\n",
       " ('F', 1),\n",
       " ('S', 1),\n",
       " ('L', 1),\n",
       " ('á', 1),\n",
       " ('4', 1),\n",
       " ('7', 1),\n",
       " ('-', 1),\n",
       " ('x', 1),\n",
       " ('2', 1),\n",
       " ('É', 1),\n",
       " ('j', 1),\n",
       " ('ê', 1)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Resposta 2\n",
    "from collections import Counter\n",
    "text = 'Brasil, oficialmente República Federativa do Brasil é o maior país da América do Sul e da região da \\\n",
    "América Latina, sendo o quinto maior do mundo em área territorial (equivalente a 47 porcento do território \\\n",
    "sul-americano) e sexto em população (com mais de 200 milhões de habitantes). É o único país na América onde se \\\n",
    "fala majoritariamente a língua portuguesa e o maior país lusófono do planeta, além de ser uma das nações mais \\\n",
    "multiculturais e etnicamente diversas, em decorrência da forte imigração oriunda de variados locais do mundo.'\n",
    "\n",
    "counter = Counter(text)\n",
    "counter.most_common()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3)\n",
    "Solicite ao usuário uma string e um número inteiro (n). Armaze ambos em variáveis. Remova da string os caracteres de 0 até n e imprima a string resultante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Entre com a string desejada:  exemplo\n",
      "Forneça o número inteiro:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plo\n"
     ]
    }
   ],
   "source": [
    "string = input('Entre com a string desejada: ')\n",
    "inteiro = int(input('Forneça o número inteiro: '))\n",
    "\n",
    "print(string[inteiro:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}