01-python-intro/aula-01/Aula 01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [**Py-Intro**] Aula 01\n",
    "# Instalando Python, introdução a bibliotecas e estruturas de dados\n",
    "\n",
    "## O que você vai aprender nesta aula?\n",
    "\n",
    "Após o término da aula você terá aprendido:\n",
    "- Informações úteis sobre a linguagem Python\n",
    "- Instalar o python\n",
    "- O que é o Jupyter Notebook, como instalá-lo e rodá-lo \n",
    "- Usar o ambiente virtual\n",
    "- Instalar bibliotecas\n",
    "- Acessar páginas usando Python\n",
    "- Estruturas de dados do Python: listas e dicionários\n",
    "\n",
    "# Sobre a linguagem Python\n",
    "\n",
    "Se você já conhece a linguagem e está animado em aprendê-la já pode seguir para a próxima seção.\n",
    "Se, mesmo assim, você ainda estiver curioso para saber mais sobre Python fique convidado a ler os próximos parágrafos.\n",
    "\n",
    "Python é uma linguagem simples, enxuta e poderosa. Com poucas linhas e sintaxe clara é possível executar tarefas complexas. Essa característica se dá, pois os tipos de dados de alto nível permitem fazer operações complexas de uma única vez, além de não ser necessário declarar variáveis ou tipos dos argumentos.\n",
    "\n",
    "Python vem com pilhas inclusas. Em sua biblioteca padrão há soluções para diversos tipos de problemas recorrentes, como:\n",
    "- Interface gráfica (tkinter)\n",
    "- Internet (requisições HTTP, email, sockets etc.)\n",
    "- Data, hora e calendário\n",
    "- Acesso a arquivos e pastas\n",
    "- Execução de outras aplicações/processos\n",
    "- E muito mais: https://docs.python.org/3/library/\n",
    "\n",
    "A linguagem foi criada em 1991 e desde então vem crescendo constantemente ano a ano, tanto no quesito de número de usuário quanto em atualizações e melhorias do interpretador e da linguagem em si. Atualmente Python está na versão 3.5 que trouxe várias features interessantes que podem ser conferidas [aqui](https://docs.python.org/3.5/whatsnew/changelog.html).\n",
    "\n",
    "Muitas empresas como Google, Facebook, Mozilla, Microsoft, Intel, IBM, Globo e Magazine Luiza usam Python em produtos como Instagram, YouTube e o g1 (portal de notícias da globo).\n",
    "\n",
    "*PS: Dica para vida: os patrocinadores de grandes eventos como, por exemplo PyCon [2015](https://us.pycon.org/2015/) e [2016](https://us.pycon.org/2016/),  usam e estão patrocinando a linguagem. E isso também vale para **qualquer outra tecnlogia**.*\n",
    "\n",
    "Python é uma linguagem interpretada, ou seja, seu código-fonte executado diretamente pelo interpretador, sem precisar de compilar o programa em instruções de linguagem de máquina.\n",
    "\n",
    "*PS: para agilizar a execução de módulos o interpretador do Python cria caches. Para saber mais, veja: [“Compiled” Python files](https://docs.python.org/3/tutorial/modules.html#compiled-python-files)*\n",
    "\n",
    "Por ser interpretada a Python ganha diversas vantagens, como:\n",
    "- Ganho de tempo por não precisar compilar/linkar o programa\n",
    "- Interpretador pode ser usado de forma interativa tornando possível realizar testes e experimentos\n",
    "- Este \"caderno\" - o jupyter notebook\n",
    "\n",
    "A linguagem possui 20 príncipios que guiam seu desenvolvimento e podem ser conferidos rodando o seguinte comando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora é hora de por as mãos na massa! Vamos do começo:\n",
    "\n",
    "## Instalando o Python 3.5\n",
    "\n",
    "Caso você já tenha o Python 3.5 siga para a próxima sessão!\n",
    "\n",
    "#### Debian e derivados (ubuntu, mint etc.)\n",
    "\n",
    "    $ sudo apt-get install python3.5\n",
    "\n",
    "#### Windows e OS X\n",
    "\n",
    "https://www.python.org/downloads/\n",
    "\n",
    "Caso você esteja usando o windows não esqueça de marcar a opção: \"Add Python.exe to Path\", como mostrado na seguinte imagem:\n",
    "\n",
    "![Instalando o Python no Windows](http://tutorial.djangogirls.org/pt/python_installation/images/add_python_to_windows_path.png)\n",
    "<center>(imagem retirada do [Django Girls Tutorial](http://tutorial.djangogirls.org/pt/))</center>\n",
    "\n",
    "## Virtualenv (Ambiente virtual)\n",
    "\n",
    "O virtualenv é uma ferramenta que serve para manter as dependências de projetos diferentes em pastas separadas, desse modo é possível trabalhar me um projeto usando, por exemplo, o Django 1.9 enquanto se mantém um projeto antigo que usa a versão 1.5 do framework.\n",
    "\n",
    "O virtualenv cria uma pasta contendo todas as dependências que um projeto Python necessita.\n",
    "\n",
    "O virtualenv já vem instalado no Python 3.5, para criar um novo ambiente faça:\n",
    "\n",
    "##### Linux e Mac\n",
    "    $ python3.5 -m venv env\n",
    "##### Windows\n",
    "Abra o programa de linha de comando do Windows e digite o comando abaixo. Isso pode ser feito apertando o `botão do windows + R`, digitando `cmd` e apertando ENTER.\n",
    "\n",
    "    > C:\\Python3.5\\python -m venv env\n",
    "\n",
    "Esse comando criará uma pasta chamada **env/** contendo os executáveis do Python e uma cópia do pip para instalar outros pacotes. Vale lembrar que o nome do ambiente virtual **env** pode ser trocado por qualquer outro.\n",
    "\n",
    "Para usar o virtualenv é necessário antes que ele seja ativado:\n",
    "##### Linux e Mac\n",
    "    $ source env/bin/activate\n",
    "##### Windows\n",
    "    > env\\Scripts\\activate\n",
    "    \n",
    "Para sair de um ambiente virtual use o comando `deactivate`.\n",
    "    \n",
    "Agora nosso ambiente virtual está pronto para ser usado!\n",
    "\n",
    "# Instalando pacotes com o pip\n",
    "\n",
    "O pip permite instalar pacotes Python (listados no [PyPI: the Python Package Index](http://pypi.python.org/)) de forma fácil. O pip significa \"**p**ip **i**nstall **packages**\" (ou pip instala pacotes).\n",
    "\n",
    "Por exemplo, vamos instalar a biblioteca requests que usaremos mais para frente nesta aula:\n",
    "\n",
    "    (env) $ pip install requests\n",
    "\n",
    "## Jupyter Notebook\n",
    "\n",
    "\n",
    "O Jupyter Notebook é uma aplicação web que permite a criação e compatilhamento de documentos (notebooks) que contém código ao vivo, equações, visualizações e textos explanatórios. Ele é muito utilizado para transformação de dados, modelagem estatística, simulação numérica, aprendizado de máquina e ensino.\n",
    "\n",
    "Para rodá-lo em sua máquina é preciso: instalar, rodar o servidor e acessr pelo navegador! É mais simples do que parece, vamos fazer esses passos.\n",
    "\n",
    "### Instalando\n",
    "\n",
    "Vamos instalar o jupyter notebook executando o seguinte comando:\n",
    "\n",
    "    (env) $ pip install jupyter[notebook]\n",
    "    \n",
    "#### No linux\n",
    "\n",
    "Caso não seja possível instalar o jupyter[notebook] rode:\n",
    "```\n",
    "    $ sudo apt-get install build-essential python3.5-dev\n",
    "    (env) $ pip install --upgrade pip\n",
    "    (env) $ pip install jupyter[notebook]\n",
    "```    \n",
    "### Rodando\n",
    "\n",
    "Não esqueça de baixar este documento (Aula01.ipynb) e rodar o jupyter notebook na **mesma pasta**.\n",
    "\n",
    "Para rodá-lo e tornar possivel o acesso do notebook pelo navegador, execute o seguinte comando:\n",
    "\n",
    "    (env) $ jupyter notebook\n",
    "\n",
    "Agora é só acessar a página http://localhost:8888/notebooks (que deve ter sido aberta automaticamente) e abrir o notebook Aula01.ipynb que já estamos prontos para codificar!\n",
    "\n",
    "Para rodar um código específico clique na caixa do código e pressione CTRL+Enter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Acessando páginas web\n",
    "\n",
    "Nosso primeiro exemplo será criar o código de uma aplicação que nos permite baixar o código-fonte de sites.\n",
    "\n",
    "Para isso vamos usar a biblioteca `requests` que foi instalada em um passo anterior (caso você não tenha instalado rode `pip install requests`).\n",
    "\n",
    "Primeiro preciamos importar a `requests`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos fazer uma requisição HTTP ao Github para baixar o conteúdo do repositório deste curso (através da URL https://github.com/lamenezes/python-intro):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://github.com/lamenezes/python-intro'  # não é necessário declarar variáveis em python\n",
    "response = requests.get(url)  # e nem especificar seu tipo\n",
    "response.status_code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "200 é o código de resposta que informa que a requisição foi bem sucedida (ou OK).\n",
    "\n",
    "*PS: No curso de Desenvolvimento Web com Django será explicado com calma como funciona o protocolo HTTP.*\n",
    "\n",
    "Agora vamos analisar os cabeçalhos dessa resposta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Strict-Transport-Security': 'max-age=31536000; includeSubdomains; preload', 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-cache', 'X-Served-By': 'b437fa0c9608399c74bf50b5c3f52799', 'Transfer-Encoding': 'chunked', 'Set-Cookie': 'logged_in=no; domain=.github.com; path=/; expires=Tue, 06 May 2036 01:53:29 -0000; secure; HttpOnly, _gh_sess=eyJzZXNzaW9uX2lkIjoiM2RkNGU5ZTFkMmU5YmE4ZGFmZTEwOTFlNWI5YjEwMzciLCJzcHlfcmVwbyI6ImxhbWVuZXplcy9weXRob24taW50cm8iLCJzcHlfcmVwb19hdCI6MTQ2MjQ5OTYwOSwiX2NzcmZfdG9rZW4iOiJWWHJaMGRBeFZjT0ZDZGtQcDRyd04wZzZ4ZktaRTJENFM0MlJYalJ6dVNVPSIsImZsYXNoIjp7ImRpc2NhcmQiOlsiYW5hbHl0aWNzX2xvY2F0aW9uIl0sImZsYXNoZXMiOnsiYW5hbHl0aWNzX2xvY2F0aW9uIjoiLzx1c2VyLW5hbWU%2BLzxyZXBvLW5hbWU%2BIn19fQ%3D%3D--db707e407a9cbccdacd5c699d8f9c721cfe0668b; path=/; secure; HttpOnly', 'X-Content-Type-Options': 'nosniff', 'X-UA-Compatible': 'IE=Edge,chrome=1', 'Date': 'Fri, 06 May 2016 01:53:29 GMT', 'Server': 'GitHub.com', 'X-XSS-Protection': '1; mode=block', 'Content-Encoding': 'gzip', 'X-Request-Id': '20221edde149239d2d332bace865ce62', 'Vary': 'X-PJAX, Accept-Encoding', 'X-GitHub-Request-Id': 'BADFDA80:6458:5105BD3:572BF919', 'X-Runtime': '0.049845', 'X-Frame-Options': 'deny', 'Public-Key-Pins': 'max-age=5184000; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains', 'Content-Security-Policy': \"default-src 'none'; base-uri 'self'; block-all-mixed-content; child-src render.githubusercontent.com; connect-src 'self' uploads.github.com status.github.com api.github.com www.google-analytics.com github-cloud.s3.amazonaws.com api.braintreegateway.com client-analytics.braintreegateway.com wss://live.github.com; font-src assets-cdn.github.com; form-action 'self' github.com gist.github.com; frame-ancestors 'none'; frame-src render.githubusercontent.com; img-src 'self' data: assets-cdn.github.com identicons.github.com www.google-analytics.com collector.githubapp.com *.gravatar.com *.wp.com checkout.paypal.com *.githubusercontent.com; media-src 'none'; object-src assets-cdn.github.com; plugin-types application/x-shockwave-flash; script-src assets-cdn.github.com; style-src 'unsafe-inline' assets-cdn.github.com\", 'Status': '200 OK'}\n"
     ]
    }
   ],
   "source": [
    "print(response.headers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O atributo headers de response (`response.headers`) nos trouxe os cabeçalhos em forma de um dicionário (ou dict). O dict é uma estrutura de dados do Python utilizada para armazenar informações na forma de chave e valor envoltas por chaves {}. Dicts serão explicados mais para frente.\n",
    "\n",
    "Por motivos técnicos a saída foi apresentada em um formato difícil de ler, para melhorá-la podemos fazer um pequeno workaround:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Cache-Control': 'no-cache',\n",
       " 'Content-Encoding': 'gzip',\n",
       " 'Content-Security-Policy': \"default-src 'none'; base-uri 'self'; block-all-mixed-content; child-src render.githubusercontent.com; connect-src 'self' uploads.github.com status.github.com api.github.com www.google-analytics.com github-cloud.s3.amazonaws.com api.braintreegateway.com client-analytics.braintreegateway.com wss://live.github.com; font-src assets-cdn.github.com; form-action 'self' github.com gist.github.com; frame-ancestors 'none'; frame-src render.githubusercontent.com; img-src 'self' data: assets-cdn.github.com identicons.github.com www.google-analytics.com collector.githubapp.com *.gravatar.com *.wp.com checkout.paypal.com *.githubusercontent.com; media-src 'none'; object-src assets-cdn.github.com; plugin-types application/x-shockwave-flash; script-src assets-cdn.github.com; style-src 'unsafe-inline' assets-cdn.github.com\",\n",
       " 'Content-Type': 'text/html; charset=utf-8',\n",
       " 'Date': 'Fri, 06 May 2016 01:53:29 GMT',\n",
       " 'Public-Key-Pins': 'max-age=5184000; pin-sha256=\"WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=\"; pin-sha256=\"RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=\"; pin-sha256=\"k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws=\"; pin-sha256=\"K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=\"; pin-sha256=\"IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=\"; pin-sha256=\"iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0=\"; pin-sha256=\"LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A=\"; includeSubDomains',\n",
       " 'Server': 'GitHub.com',\n",
       " 'Set-Cookie': 'logged_in=no; domain=.github.com; path=/; expires=Tue, 06 May 2036 01:53:29 -0000; secure; HttpOnly, _gh_sess=eyJzZXNzaW9uX2lkIjoiM2RkNGU5ZTFkMmU5YmE4ZGFmZTEwOTFlNWI5YjEwMzciLCJzcHlfcmVwbyI6ImxhbWVuZXplcy9weXRob24taW50cm8iLCJzcHlfcmVwb19hdCI6MTQ2MjQ5OTYwOSwiX2NzcmZfdG9rZW4iOiJWWHJaMGRBeFZjT0ZDZGtQcDRyd04wZzZ4ZktaRTJENFM0MlJYalJ6dVNVPSIsImZsYXNoIjp7ImRpc2NhcmQiOlsiYW5hbHl0aWNzX2xvY2F0aW9uIl0sImZsYXNoZXMiOnsiYW5hbHl0aWNzX2xvY2F0aW9uIjoiLzx1c2VyLW5hbWU%2BLzxyZXBvLW5hbWU%2BIn19fQ%3D%3D--db707e407a9cbccdacd5c699d8f9c721cfe0668b; path=/; secure; HttpOnly',\n",
       " 'Status': '200 OK',\n",
       " 'Strict-Transport-Security': 'max-age=31536000; includeSubdomains; preload',\n",
       " 'Transfer-Encoding': 'chunked',\n",
       " 'Vary': 'X-PJAX, Accept-Encoding',\n",
       " 'X-Content-Type-Options': 'nosniff',\n",
       " 'X-Frame-Options': 'deny',\n",
       " 'X-GitHub-Request-Id': 'BADFDA80:6458:5105BD3:572BF919',\n",
       " 'X-Request-Id': '20221edde149239d2d332bace865ce62',\n",
       " 'X-Runtime': '0.049845',\n",
       " 'X-Served-By': 'b437fa0c9608399c74bf50b5c3f52799',\n",
       " 'X-UA-Compatible': 'IE=Edge,chrome=1',\n",
       " 'X-XSS-Protection': '1; mode=block'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(response.headers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar um cabeçalho específico por sua chave fazemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'text/html; charset=utf-8'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response.headers['content-type']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fri, 06 May 2016 01:53:29 GMT'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response.headers['date']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n\\n\\n\\n<!DOCTYPE html>\\n<html lang=\"en\" class=\"\">\\n  <head prefix=\"og: http://ogp.me/ns# fb: http://ogp.me/ns/fb# object: http://ogp.me/ns/object# article: http://ogp.me/ns/article# profile: http://ogp.me/ns/profile#\">\\n    <meta charset=\\'utf-8\\'>\\n\\n    <link crossorigin=\"anonymous\" href=\"https://assets-cdn.github.com/assets/frameworks-64d9cf09923fe989623ec42695fc7653a16513c1a63441ee66f4b81ef555ae49.css\" media=\"all\" rel=\"stylesheet\" />\\n    <link crossorigin=\"anonymous\" href=\"https://assets-cdn.github.com/assets/github-7d5c7e87c2f34802bf90a223dbdaf4f7a2511aa5c3dd80c7bc2ad86f36e0ac56.css\" media=\"all\" rel=\"stylesheet\" />\\n    \\n    \\n    <link crossorigin=\"anonymous\" href=\"https://assets-cdn.github.com/assets/site-d2013a78fb2b0b2d9afce49f4cf82965d3f075b6b021bf51aa28d8df766f2ba4.css\" media=\"all\" rel=\"stylesheet\" />\\n    \\n\\n    <link as=\"script\" href=\"https://assets-cdn.github.com/assets/frameworks-a7834ad5e30f73a7017adee72b9e733ae5574cf80cb92924a384d22d72a836e1.js\" rel=\"preload\" />\\n    \\n    <link as=\"s'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response.text[:1000]  # retorna os 1000 primeiros caracteres do conteúdo da resposta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como visto anteriormente a biblioteca requests permite o envio de requisições HTTP de maneira extremamante fácil. Para obter mais informações sobre a `requests` acesse a [doumentação oficial](http://docs.python-requests.org/en/master/).\n",
    "\n",
    "Agora que já aprendemos o básico podemos partir para um exemplo mais interessante.\n",
    "\n",
    "### Acessando os dados da API do github\n",
    "\n",
    "O Github oferece uma API que fornece dados de seus repositórios públicos. São dadas informações como quantos projetos estão cadastrados na plataforma, quantos contribuidores trabalharam em quais repositórios, a quais organizações essas fazem parte e muito mais. (mais informações na [documentação oficial](https://developer.github.com/v3/))\n",
    "\n",
    "O acesso aos dados dessa API é feito através do envio de requisições HTTP para diferentes caminhos na URL base https://api.github.com/. Caso você queira testar a API, pode acessar o link anterior pelo navegador e mudar a URL manualmente, porém nosso foco aqui será usar a biblioteca `requests` para pegar esses dados.\n",
    "\n",
    "Todas as respostas da API são em formato JSON. O JSON siginifca JavaScript Object Notation e pronuncia-se \"djêizon\" e é um formato fácil de processar e simples de utilizar. Para mais informações sobre o JSON acesse a [página oficial](http://json.org/). Falaremos mais sobre JSON no decorrer do curso, mas fique tranquilo que não segredo há algum nesse assunto.\n",
    "\n",
    "Vamos testar a API e pegar os repositórios de um usuário específico através da URL https://api.github.com/users/lamenezes/repos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response = requests.get('https://api.github.com/users/lamenezes/repos')\n",
    "response.status_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[{\"id\":42411070,\"name\":\"Adafruit_Python_CharLCD\",\"full_name\":\"lamenezes/Adafruit_Python_CharLCD\",\"owner\":{\"login\":\"lamenezes\",\"id\":3208493,\"avatar_url\":\"https://avatars.githubusercontent.com/u/3208493?v=3\",\"gravatar_id\":\"\",\"url\":\"https://api.github.com/users/lamenezes\",\"html_url\":\"https://github.com/lamenezes\",\"followers_url\":\"https://api.github.com/users/lamenezes/followers\",\"following_url\":\"https://api.github.com/users/lamenezes/following{/other_user}\",\"gists_url\":\"https://api.github.com/users/lamenezes/gists{/gist_id}\",\"starred_url\":\"https://api.github.com/users/lamenezes/starred{/owner}{/repo}\",\"subscriptions_url\":\"https://api.github.com/users/lamenezes/subscriptions\",\"organizations_url\":\"https://api.github.com/users/lamenezes/orgs\",\"repos_url\":\"https://api.github.com/users/lamenezes/repos\",\"events_url\":\"https://api.github.com/users/lamenezes/events{/privacy}\",\"received_events_url\":\"https://api.github.com/users/lamenezes/received_events\",\"type\":\"User\",\"site_admin\":false},\"private\":'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response.text[:1000]  # pegando os primeiros 1000 caracters do conteúdo da resposta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A resposta trouxe todos os repositórios do usuário `lamenezes` em uma string no padrão JSON.\n",
    "\n",
    "Essa string não é interessante para nós, pois é difícil acessar dados específicos do JSON através dela. Seria muito melhor para nós se essa resposta fosse traduzida para um dicionário do Python (que possui sintaxe muito parecida com o JSON).\n",
    "\n",
    "Normalmente teríamos que importar a biblioteca json e realizar a conversão, no pior caso poderia ser necessário escrever um parser específico para tratar casos especiais.\n",
    "\n",
    "No entanto, a biblioteca `requests` já faz esse trabalho para nós:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/{archive_format}{/ref}',\n",
       " 'assignees_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/assignees{/user}',\n",
       " 'blobs_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/git/blobs{/sha}',\n",
       " 'branches_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/branches{/branch}',\n",
       " 'clone_url': 'https://github.com/lamenezes/Adafruit_Python_CharLCD.git',\n",
       " 'collaborators_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/collaborators{/collaborator}',\n",
       " 'comments_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/comments{/number}',\n",
       " 'commits_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/commits{/sha}',\n",
       " 'compare_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/compare/{base}...{head}',\n",
       " 'contents_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/contents/{+path}',\n",
       " 'contributors_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/contributors',\n",
       " 'created_at': '2015-09-13T20:08:52Z',\n",
       " 'default_branch': 'master',\n",
       " 'deployments_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/deployments',\n",
       " 'description': 'Python library for accessing Adafruit character LCDs from a Raspberry Pi or BeagleBone Black.',\n",
       " 'downloads_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/downloads',\n",
       " 'events_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/events',\n",
       " 'fork': True,\n",
       " 'forks': 0,\n",
       " 'forks_count': 0,\n",
       " 'forks_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/forks',\n",
       " 'full_name': 'lamenezes/Adafruit_Python_CharLCD',\n",
       " 'git_commits_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/git/commits{/sha}',\n",
       " 'git_refs_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/git/refs{/sha}',\n",
       " 'git_tags_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/git/tags{/sha}',\n",
       " 'git_url': 'git://github.com/lamenezes/Adafruit_Python_CharLCD.git',\n",
       " 'has_downloads': True,\n",
       " 'has_issues': False,\n",
       " 'has_pages': False,\n",
       " 'has_wiki': True,\n",
       " 'homepage': None,\n",
       " 'hooks_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/hooks',\n",
       " 'html_url': 'https://github.com/lamenezes/Adafruit_Python_CharLCD',\n",
       " 'id': 42411070,\n",
       " 'issue_comment_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/issues/comments{/number}',\n",
       " 'issue_events_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/issues/events{/number}',\n",
       " 'issues_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/issues{/number}',\n",
       " 'keys_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/keys{/key_id}',\n",
       " 'labels_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/labels{/name}',\n",
       " 'language': 'Python',\n",
       " 'languages_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/languages',\n",
       " 'merges_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/merges',\n",
       " 'milestones_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/milestones{/number}',\n",
       " 'mirror_url': None,\n",
       " 'name': 'Adafruit_Python_CharLCD',\n",
       " 'notifications_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/notifications{?since,all,participating}',\n",
       " 'open_issues': 0,\n",
       " 'open_issues_count': 0,\n",
       " 'owner': {'avatar_url': 'https://avatars.githubusercontent.com/u/3208493?v=3',\n",
       "  'events_url': 'https://api.github.com/users/lamenezes/events{/privacy}',\n",
       "  'followers_url': 'https://api.github.com/users/lamenezes/followers',\n",
       "  'following_url': 'https://api.github.com/users/lamenezes/following{/other_user}',\n",
       "  'gists_url': 'https://api.github.com/users/lamenezes/gists{/gist_id}',\n",
       "  'gravatar_id': '',\n",
       "  'html_url': 'https://github.com/lamenezes',\n",
       "  'id': 3208493,\n",
       "  'login': 'lamenezes',\n",
       "  'organizations_url': 'https://api.github.com/users/lamenezes/orgs',\n",
       "  'received_events_url': 'https://api.github.com/users/lamenezes/received_events',\n",
       "  'repos_url': 'https://api.github.com/users/lamenezes/repos',\n",
       "  'site_admin': False,\n",
       "  'starred_url': 'https://api.github.com/users/lamenezes/starred{/owner}{/repo}',\n",
       "  'subscriptions_url': 'https://api.github.com/users/lamenezes/subscriptions',\n",
       "  'type': 'User',\n",
       "  'url': 'https://api.github.com/users/lamenezes'},\n",
       " 'private': False,\n",
       " 'pulls_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/pulls{/number}',\n",
       " 'pushed_at': '2015-09-13T20:10:42Z',\n",
       " 'releases_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/releases{/id}',\n",
       " 'size': 100,\n",
       " 'ssh_url': 'git@github.com:lamenezes/Adafruit_Python_CharLCD.git',\n",
       " 'stargazers_count': 0,\n",
       " 'stargazers_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/stargazers',\n",
       " 'statuses_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/statuses/{sha}',\n",
       " 'subscribers_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/subscribers',\n",
       " 'subscription_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/subscription',\n",
       " 'svn_url': 'https://github.com/lamenezes/Adafruit_Python_CharLCD',\n",
       " 'tags_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/tags',\n",
       " 'teams_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/teams',\n",
       " 'trees_url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD/git/trees{/sha}',\n",
       " 'updated_at': '2015-09-13T20:08:53Z',\n",
       " 'url': 'https://api.github.com/repos/lamenezes/Adafruit_Python_CharLCD',\n",
       " 'watchers': 0,\n",
       " 'watchers_count': 0}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repositorios = response.json()\n",
    "repo = repositorios[0]  # pegando apenas o primeiro repositório por brevidade\n",
    "repo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A resposta nos trouxe uma `lista` de `dicionários` com as informações dos repositórios do usuário `lamenezes`. Agora fica a dúvida: o que exatamente é uma lista e um dicionário?\n",
    "\n",
    "### Listas\n",
    "\n",
    "Listas, como o próprio nome sugere, são estruturas de dados mutáveis que armanzenam listas de valores. Os valores da lista são acessados pelo número relativo a sua posição.\n",
    "\n",
    "Ao invés de gastar dedos digitando mais sobre o que é uma lista é mais fácil demonstrá-la:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2.5, 3, 4.5, 5]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros = [1, 2.5, 3, 4.5, 5]\n",
    "numeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[-1]  # -1 acessa o último elemento da lista!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas podem armazenar qualquer tipo de dados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foobar', False, ['a', 'b', 'c'], {'foo': 'bar'}, 10, -0.5]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = ['foobar', False, ['a', 'b', 'c'], {'foo': 'bar'}, 10, -0.5]\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fazemos assim para verificar se um elemento faz parte de uma lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'foobar' in lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc' in lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-0.5 in lista "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para saber o tamanho de uma lista basta usar a função `len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lista[2])  # o segundo elemento da lista é uma lista com 3 elementos!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para remover elementos de uma lista existe a palavra reservada `del` que é utilizada assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foobar', False, ['a', 'b', 'c'], {'foo': 'bar'}, 10, -0.5]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foobar', False, ['a', 'b', 'c'], 10, -0.5]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del lista[3]\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foobar', False, ['a', 'b', 'c'], 10]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del lista[-1]  # remove último elemento\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterar uma lista é simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2.5\n",
      "3\n",
      "4.5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for numero in numeros:\n",
    "    print(numero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O for do Python, diferentemente de outras linguagens como C e Java, faz o controle dos índices internamente.\n",
    "\n",
    "Vamos fazer mais um exemplo para deixar claro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros = range(1, 11)  # cria uma lista de números de 1 a 10\n",
    "list(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "for numero in numeros:\n",
    "    print(numero ** 2)  # numero elevado a segunda potência"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função range(inicio, fim) cria listas de valores no intervalo de inicio até fim - 1. Ao lidar com intervalos no python o primeiro número é sempre incluso e o último excluído. Segue alguns exemplos de uso da função range()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))  # números de 0 a 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10, 20))  # números de 10 a 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10, 21))  # números de 10 a 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercício\n",
    "\n",
    "Crie uma lista de números de 2 a 8 e imprima cada número vezes pi. Substiua os ... por código python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "numeros = ...  # crie a lista de números de 2 a 8\n",
    "for numero in numeros:\n",
    "    print( ... )  # imprime o número vezes pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercicio\n",
    "\n",
    "Crie uma lista de preços de produtos em dólar (somente números) e imprima seu valor convertido para reais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "taxa_dolar = 3.53  # mude esse valor caso o valor do dólar tenha mudado\n",
    "preços = ...  # python 3 permite declarar variáveis com acentos\n",
    "for preço in preço:\n",
    "    print(...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicionários\n",
    "\n",
    "Dicionários são estruturas de dados utilizadas para armazenar conjuntos de chaves e valores. Em algumas linguagens também são conhecidos como mapaemento.\n",
    "\n",
    "A diferança de uso entre lista e dicionáro é que o último é acessado por *chaves* e não pela *posição*. As chaves podem ser inteiros, strings, booleanos e tuplas (este será visto na próxima aula).\n",
    "\n",
    "A seguir temos alguns simples exemplos de uso de diconários.\n",
    "\n",
    "Criar um dict é simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': 7, 'joao': 5, 'maria': 9}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "notas = {'joao': 5, 'maria': 9, 'ana': 7}\n",
    "notas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar os elementos basta usar sua chave:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "notas['ana']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "notas['joao']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para alterar algum valor fazemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': 7, 'joao': 6.5, 'maria': 9}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "notas['joao'] = 6.5\n",
    "notas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ana': 7.5, 'joao': 6.5, 'maria': 9}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "notas['ana'] = 7.5\n",
    "notas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificamos se uma chave existe no dicionário da seguinte maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'joao' in notas  # verifica se o valor é uma chave do dicionário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'joana' in notas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ana' in notas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar somente as chaves fazemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['maria', 'joao', 'ana']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(notas.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar somente os valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 6.5, 7.5]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(notas.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ter uma lista contendo as chaves e valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('maria', 9), ('joao', 6.5), ('ana', 7.5)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(notas.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para iterar dicionáros é preciso ter cuidado. Por padrão as chaves do dicionário são iteradas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maria\n",
      "joao\n",
      "ana\n"
     ]
    }
   ],
   "source": [
    "for chave in notas:\n",
    "    print(chave)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso você queira imprimir os valores é preciso usar `notas.values()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "6.5\n",
      "7.5\n"
     ]
    }
   ],
   "source": [
    "for valor in notas.values():\n",
    "    print(valor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para iterar tanto a chave quanto o valor use a função `notas.items()` como mostrado a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maria 9\n",
      "joao 6.5\n",
      "ana 7.5\n"
     ]
    }
   ],
   "source": [
    "for chave, valor in notas.items():\n",
    "    print(chave, valor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ficar mais claro podemos mudar os nomes das variáveis e para ficar mais inteligível formatar a saída:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maria tirou 9.\n",
      "Joao tirou 6.5.\n",
      "Ana tirou 7.5.\n"
     ]
    }
   ],
   "source": [
    "for nome, nota in notas.items():\n",
    "    print('{0} tirou {1}.'.format(nome.capitalize(), nota))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('maria', 9), ('joao', 6.5), ('ana', 7.5)]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(notas.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como visto acima o `notas.items()` retorna uma lista de chaves e valores. Por esse motivo a cada iteração temos acesso a cada chave e valor do dicionário `notas`, tornando possível essa iteração mais simples e semântica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que já temos uma noção das estruturas de dados utilizadas, podemos continuar a visualizar as informações dos repositórios do github:\n",
    "\n",
    "*PS: relaxe, pois nas próximas aulas veremos a fundo essas estruturas!*\n",
    "\n",
    "### De volta à API do github\n",
    "\n",
    "Anteriormente realizamos uma requisição à API do github para pegar os repositórios do usuário `lamenezes` e armazenamos a resposta na variável `response`. Essa variável ainda está disponível para nós, o que nos permite continuar nosso exemplo anterior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_url': 'https://api.github.com/repos/lamenezes/dotfiles/{archive_format}{/ref}',\n",
       " 'assignees_url': 'https://api.github.com/repos/lamenezes/dotfiles/assignees{/user}',\n",
       " 'blobs_url': 'https://api.github.com/repos/lamenezes/dotfiles/git/blobs{/sha}',\n",
       " 'branches_url': 'https://api.github.com/repos/lamenezes/dotfiles/branches{/branch}',\n",
       " 'clone_url': 'https://github.com/lamenezes/dotfiles.git',\n",
       " 'collaborators_url': 'https://api.github.com/repos/lamenezes/dotfiles/collaborators{/collaborator}',\n",
       " 'comments_url': 'https://api.github.com/repos/lamenezes/dotfiles/comments{/number}',\n",
       " 'commits_url': 'https://api.github.com/repos/lamenezes/dotfiles/commits{/sha}',\n",
       " 'compare_url': 'https://api.github.com/repos/lamenezes/dotfiles/compare/{base}...{head}',\n",
       " 'contents_url': 'https://api.github.com/repos/lamenezes/dotfiles/contents/{+path}',\n",
       " 'contributors_url': 'https://api.github.com/repos/lamenezes/dotfiles/contributors',\n",
       " 'created_at': '2013-12-13T13:49:10Z',\n",
       " 'default_branch': 'master',\n",
       " 'deployments_url': 'https://api.github.com/repos/lamenezes/dotfiles/deployments',\n",
       " 'description': 'My dotfiles',\n",
       " 'downloads_url': 'https://api.github.com/repos/lamenezes/dotfiles/downloads',\n",
       " 'events_url': 'https://api.github.com/repos/lamenezes/dotfiles/events',\n",
       " 'fork': False,\n",
       " 'forks': 1,\n",
       " 'forks_count': 1,\n",
       " 'forks_url': 'https://api.github.com/repos/lamenezes/dotfiles/forks',\n",
       " 'full_name': 'lamenezes/dotfiles',\n",
       " 'git_commits_url': 'https://api.github.com/repos/lamenezes/dotfiles/git/commits{/sha}',\n",
       " 'git_refs_url': 'https://api.github.com/repos/lamenezes/dotfiles/git/refs{/sha}',\n",
       " 'git_tags_url': 'https://api.github.com/repos/lamenezes/dotfiles/git/tags{/sha}',\n",
       " 'git_url': 'git://github.com/lamenezes/dotfiles.git',\n",
       " 'has_downloads': True,\n",
       " 'has_issues': True,\n",
       " 'has_pages': False,\n",
       " 'has_wiki': True,\n",
       " 'homepage': '',\n",
       " 'hooks_url': 'https://api.github.com/repos/lamenezes/dotfiles/hooks',\n",
       " 'html_url': 'https://github.com/lamenezes/dotfiles',\n",
       " 'id': 15164551,\n",
       " 'issue_comment_url': 'https://api.github.com/repos/lamenezes/dotfiles/issues/comments{/number}',\n",
       " 'issue_events_url': 'https://api.github.com/repos/lamenezes/dotfiles/issues/events{/number}',\n",
       " 'issues_url': 'https://api.github.com/repos/lamenezes/dotfiles/issues{/number}',\n",
       " 'keys_url': 'https://api.github.com/repos/lamenezes/dotfiles/keys{/key_id}',\n",
       " 'labels_url': 'https://api.github.com/repos/lamenezes/dotfiles/labels{/name}',\n",
       " 'language': 'Python',\n",
       " 'languages_url': 'https://api.github.com/repos/lamenezes/dotfiles/languages',\n",
       " 'merges_url': 'https://api.github.com/repos/lamenezes/dotfiles/merges',\n",
       " 'milestones_url': 'https://api.github.com/repos/lamenezes/dotfiles/milestones{/number}',\n",
       " 'mirror_url': None,\n",
       " 'name': 'dotfiles',\n",
       " 'notifications_url': 'https://api.github.com/repos/lamenezes/dotfiles/notifications{?since,all,participating}',\n",
       " 'open_issues': 0,\n",
       " 'open_issues_count': 0,\n",
       " 'owner': {'avatar_url': 'https://avatars.githubusercontent.com/u/3208493?v=3',\n",
       "  'events_url': 'https://api.github.com/users/lamenezes/events{/privacy}',\n",
       "  'followers_url': 'https://api.github.com/users/lamenezes/followers',\n",
       "  'following_url': 'https://api.github.com/users/lamenezes/following{/other_user}',\n",
       "  'gists_url': 'https://api.github.com/users/lamenezes/gists{/gist_id}',\n",
       "  'gravatar_id': '',\n",
       "  'html_url': 'https://github.com/lamenezes',\n",
       "  'id': 3208493,\n",
       "  'login': 'lamenezes',\n",
       "  'organizations_url': 'https://api.github.com/users/lamenezes/orgs',\n",
       "  'received_events_url': 'https://api.github.com/users/lamenezes/received_events',\n",
       "  'repos_url': 'https://api.github.com/users/lamenezes/repos',\n",
       "  'site_admin': False,\n",
       "  'starred_url': 'https://api.github.com/users/lamenezes/starred{/owner}{/repo}',\n",
       "  'subscriptions_url': 'https://api.github.com/users/lamenezes/subscriptions',\n",
       "  'type': 'User',\n",
       "  'url': 'https://api.github.com/users/lamenezes'},\n",
       " 'private': False,\n",
       " 'pulls_url': 'https://api.github.com/repos/lamenezes/dotfiles/pulls{/number}',\n",
       " 'pushed_at': '2016-03-21T01:07:30Z',\n",
       " 'releases_url': 'https://api.github.com/repos/lamenezes/dotfiles/releases{/id}',\n",
       " 'size': 65,\n",
       " 'ssh_url': 'git@github.com:lamenezes/dotfiles.git',\n",
       " 'stargazers_count': 3,\n",
       " 'stargazers_url': 'https://api.github.com/repos/lamenezes/dotfiles/stargazers',\n",
       " 'statuses_url': 'https://api.github.com/repos/lamenezes/dotfiles/statuses/{sha}',\n",
       " 'subscribers_url': 'https://api.github.com/repos/lamenezes/dotfiles/subscribers',\n",
       " 'subscription_url': 'https://api.github.com/repos/lamenezes/dotfiles/subscription',\n",
       " 'svn_url': 'https://github.com/lamenezes/dotfiles',\n",
       " 'tags_url': 'https://api.github.com/repos/lamenezes/dotfiles/tags',\n",
       " 'teams_url': 'https://api.github.com/repos/lamenezes/dotfiles/teams',\n",
       " 'trees_url': 'https://api.github.com/repos/lamenezes/dotfiles/git/trees{/sha}',\n",
       " 'updated_at': '2016-02-24T17:20:29Z',\n",
       " 'url': 'https://api.github.com/repos/lamenezes/dotfiles',\n",
       " 'watchers': 3,\n",
       " 'watchers_count': 3}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repositorios = response.json()  # lista de dicionários com dados de cada repositório\n",
    "repo = repositorios[11]  # vamos analisar o décimo primeiro repositório\n",
    "repo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lamenezes/dotfiles'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repo['full_name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My dotfiles'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repo['description']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2013-12-13T13:49:10Z'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repo['created_at']  # data de criação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'https://github.com/lamenezes/dotfiles'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repo['html_url']  # URL da página principal do repositório"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também temos os dados do dono (owner) do repositório:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lamenezes'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dono = repo['owner']\n",
    "dono['login']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`'owner'` é um dicionário dentro do dicionário do repositório (sim, é possível guardar dicionários dentro de dicionários)\n",
    "\n",
    "Também podemos acessar as informações diretamente sem recorrer à variável intermediária `dono`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lamenezes'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repo['owner']['login']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercicios\n",
    "\n",
    "- Quantos repositórios o usuário `lamenezes` possui?\n",
    "\n",
    "Lembrando que esses repositórios estão armazenados na lista `repositorios`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# digite o código aqui"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Imprima as URLs de todos os repositórios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# digite o código aqui"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para os próximos exercícios será necessáro pegar os repositórios do usuário `gvanrossum`. Use a biblioteca requests e faça uma requição à API do github (https://api.github.com/) como demostrado anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "response = ...\n",
    "response.status_code  # status_code deve ser 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora pegue o conteúdo da resposta em formato JSON e atribua à variável `repos`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "repos = ...\n",
    "len(repos)  # esta linha deve retornar 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Imprima o nome e descrição de todos os repositórios do `gvanrossum`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(u'gvanrossum/500lines', u'500 Lines or Less')\n",
      "(u'gvanrossum/asyncio', u'This project is the asyncio module for Python 3.3. Since Python 3.4, asyncio is part of the standard library.')\n",
      "(u'gvanrossum/ballot-box', u'Automatically exported from code.google.com/p/ballot-box')\n",
      "(u'gvanrossum/mypy', u'Optional static typing for Python')\n",
      "(u'gvanrossum/path-pep', u'PEP for a file system path protocol in Python')\n",
      "(u'gvanrossum/pyxl3', u'A Python 3 extension for writing structured and reusable inline HTML.')\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "\n",
    "response = requests.get('https://api.github.com/users/gvanrossum/repos')\n",
    "repositorios = response.json()\n",
    "for repositorio in repositorios:\n",
    "    print(repositorio['full_name'], repositorio['description'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Quantos forks o repositório gvanrossum/asyncio possui?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# digite o código aqui"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Qual o link do perfil do dono dos repositórios?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# digite o código aqui"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Última pergunta:\n",
    "\n",
    "- Quem é `gvanrossum`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fim da Aula 01"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}