aula-1-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Encontro I\n",
    "\n",
    "## Objetivo\n",
    "\n",
    "O objetivo deste primeiro encontro é discutir aspectos básicos da linguagem python tais como:\n",
    "\n",
    "1. Instalação e configuração do ambiente de programação\n",
    "    - Console python;\n",
    "    - IPython e Spyder;\n",
    "    - Anaconda (Jupyther notebook).\n",
    "2. Tipos de dados e estruturas\n",
    "    - Tipos básicos de dados;\n",
    "    - Operações e funções matemáticas básicas;\n",
    "    - Estruturas básicas de dados;\n",
    "    - Estruturas de controle;\n",
    "    - Programação funcional;\n",
    "    - Introdução ao NumPy;\n",
    "\n",
    "## 1. Instalação e configuração do ambiente de programação\n",
    "\n",
    "Todo sistema Linux já está equipado com uma ou geralmente duas versões da linguagem python. As versões mais comuns são a pyhton2.7 e a python3. Para iniciar o python no seu Linux basta abrir um terminal (CTRL + ALT + T) e digitar python. Caso queira verificar quais versões você tem instalado basta digitar python seguido da tecla TAB. Apesar de bastante simples esta forma de usar o python é pouco eficiente e uma série de ferramentas para auxiliar na produtividade e também no aprendizado da linguagem estão disponíveis.\n",
    "\n",
    "Neste primeiro contato com a linguagem vamos discutir outras duas formas de começar a programar em python. \n",
    "O programa [IPython](https://ipython.org/) é um poderoso prompt de comando para computação interativa desenvolvido para a linguagem python. IPython oferece suporte para visualização de dados interativa, sintaxe shell, tab completion e permite arquivar o histórico de código. Atualmente o projeto IPython cresceu e tornou-se um sistema multi linguagens fornecendo suporte para linguagens como Julia, R entre outras.\n",
    "\n",
    "Frequentemente o console IPython é usado em conjunto com o ambiente para desenvolvimento de computação ciêntífica [Spyder](https://pythonhosted.org/spyder/). O workflow é simples, o código python é escrito no editor Spyder e executado através do console IPython. O editor Spyder fornece recursos de edição avançados, testes interativos, debugging e introspection features. Este sistema parece mais adequado para o desenvolvimento de novos modulos e analises extensas.\n",
    "\n",
    "Dentro do escopo de data science a ferramenta [Jupyter](http://jupyter.org/) é muito popular. Jupyter notebook é uma aplicação web open-source que permite criar e compartilhar documentos que contêm código, equações, visualização e textos explicativos. Aplicações em geral envolvem, data cleaning e transformation, simulações numéricas, modelagem estatística, visualização de dados, machine learning e muito mais.\n",
    "\n",
    "Apesar de ser possível instalar cada uma das ferramentas mencionadas individualmente, uma forma mais simples de preparar o ambiente de programação python é instalar o pacote [Anaconda](https://anaconda.org/). Anaconda é uma distribuição open-source das linguagens python e R para processamento de dados em larga escala, predictive analytics e computação ciêntífica que objetiva simplificar o gerenciamento e desenvolvimento de pacotes. As versões dos pacotes são gerenciadas pelo sistema de gerenciamento de pacotes conda.\n",
    "\n",
    "Instalar o pacote Anaconda em distribuições Linux é muito fácil atráves da linha de comando do Linux. Basta seguir os seguintes passos:\n",
    "\n",
    "   - Faça o download da versão Anaconda que deseja instalar. Neste exemplo vou usar a última versão (12/01/2018) disponível no endereço https://repo.continuum.io/archive/. Você também deve escolher entre a versão 2 ou 3 do python.\n",
    "   Neste exemplo eu vou instalar a versão 3 para um computador 64 bits. Para fazer o download direto da linha de comando Linux vou usar o comando `wget`. Recomendo que faça todas essas operações no seu diretório `\\home`.\n",
    "   \n",
    "```\n",
    "wget https://repo.continuum.io/archive/Anaconda3-5.0.1-Linux-x86_64.sh\n",
    "\n",
    "```\n",
    "   - Rode o script .sh para a instalação do Anaconda e siga as instruções. Na dúvida use a configuração default. Esse comando vai criar uma pasta chamada anaconda no diretório onde você está rodando a instalação.\n",
    "   \n",
    "```\n",
    "bash Anaconda2-4.2.0-Linux-x86_64.sh -b -p ~/anaconda\n",
    "```\n",
    "\n",
    "   - Precisamos colocar o Anaconda no caminho de busca para fácil acesso via a linha de comando Linux. Para isso incluímos o diretório do Anaconda em nosso arquivo `.bashrc`.\n",
    "   \n",
    "```\n",
    "echo 'export PATH=\"~/anaconda/bin:$PATH\"' >> ~/.bashrc \n",
    "\n",
    "```\n",
    "\n",
    "   - Finalmente, atualizamos o arquivo `.bashrc` e abrimos a aplicação Anaconda\n",
    "   \n",
    "```\n",
    "source .bashrc\n",
    "anaconda-navigator\n",
    "\n",
    "```\n",
    "\n",
    "   - Podemos atualizar todos os pacotes do Anaconda via o gerenciador de pacotes conda.\n",
    "\n",
    "```\n",
    "conda update conda\n",
    "\n",
    "```\n",
    "\n",
    "Assim, terminamos o processo de instalação do pacote Anaconda e estamos prontos para começar a programar em python. \n",
    "As instruções acima foram obtidas através do website (https://medium.com/@GalarnykMichael/install-python-on-ubuntu-anaconda-65623042cb5a).\n",
    "\n",
    "## 2. Tipos de dados e estruturas\n",
    "\n",
    "### Tipos básicos de dados\n",
    "\n",
    "A linguagem python é dinamicamente tipificada, isso significa que o interpretador do python vai reconhecer o tipo de objeto que o usuário esta declarando automaticamente. Os tipos de objetos fundamentais em python são: `integer`, `floats` e `string`.\n",
    "\n",
    "Para identificar o tipo de objeto em python usamos a comando `type()` e para imprimir o resultado de uma linha de código usamos o comando `print()` veja a seguir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a1 = 10 # Definimos a1 como o integer 10\n",
    "print(type(a1))\n",
    "\n",
    "a2 = 3 # Definimos a2 como o integer 3\n",
    "print(type(a2))\n",
    "\n",
    "a3 = 10.0 # Definimos a3 como o float 10.0\n",
    "print(type(a3))\n",
    "\n",
    "a4 = 3.0 # Definimos a4 como o float 3.0\n",
    "print(type(a4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No python 3 a divisão de integer por integer já é automaticamente tipificada para float. \n",
    "Entretando, em versões mais antigas (python 2.7) essa conversão não é automática e requer o uso de pacotes específicos.\n",
    "Neste documento estamos usando a versão 3.6.2, então não precisamos nos preocupar com isso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3333333333333335\n",
      "<class 'float'>\n",
      "3.3333333333333335\n",
      "<class 'float'>\n",
      "3.3333333333333335\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "b1 = a1/a2 # Divisão integer por integer -> float\n",
    "print(b1)\n",
    "print(type(b1)) \n",
    "\n",
    "b2 = a3/a4 # Divisão float por float -> float\n",
    "print(b2)\n",
    "print(type(b2))\n",
    "\n",
    "b3 = a1/a4 # Divisão integer por float -> float\n",
    "print(b3)\n",
    "print(type(b3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um aspecto muito interessante da linguagem python é que todos os objetos tem uma classe e toda classe tem uma série de atributos associados. Por exemplo, podemos acessar o número de bits usados pelo integer 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1.bit_length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entretanto, objetos do tipo float obviamente não tem esse atributo. Você pode obter informações sobre float objetos usando o modulo `sys`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys \n",
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Internamente um float é representado como a razão entre dois integers. Para ver isso, objetos da class float tem um atributo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 1)\n",
      "(3152519739159347, 9007199254740992)\n"
     ]
    }
   ],
   "source": [
    "print(a3.as_integer_ratio())\n",
    "c1 = 0.35\n",
    "print(c1.as_integer_ratio())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O último tipo básico de dado que veremos é o `strings`. `strings` em geral são usadas para representar textos os nomes e o python tem um rico ambiente para trabalhar com strings. Veja os exemplos abaixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "t = \"isto é um objeto string\"\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objetos do tipo `str` tem um grande conjunto de atributos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Isto é um objeto string\n",
      "['isto', 'é', 'um', 'objeto', 'string']\n",
      "17\n",
      "isto|é|um|objeto|string\n",
      "o é um objeto \n",
      "3\n",
      "ISTO É UM OBJETO STRING\n",
      "isto é um objeto string\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'m|i|n|h|a| |s|e|g|u|n|d|a| |s|t|r|i|n|g'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(t.capitalize()) # capitaliza a primeira letra\n",
    "print(t.split()) # corta por palavras\n",
    "print(t.find('string')) # index da primeira letra onde a palavra string começa\n",
    "print(t.replace(\" \", \"|\")) # troca espaço em branco por |\n",
    "print(t.strip('string')) # Remove uma palavra e/ou conjunto de strings\n",
    "print(t.count('o')) # Conta a ocorrência de uma string\n",
    "print(t.upper())\n",
    "print(t.lower())\n",
    "t2 = \"minha segunda string\"\n",
    "\"|\".join(t2) # Concatena strings\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma ferramenta muito poderosa quando trabalhando com strings é expressões regulares. Python oferece tais funcionalidades no modulo `re`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponha que temos um grande conjunto de dados que contêm uma série temporal e a respectiva informação de data e hora. Em geral, a informação da data aparece em um formato que o python não reconhece naturalmente. Entretanto, a informação pode geralmente ser descrita por uma expressão regular. Considere o seguinte objeto string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "'01/18/2014 13:00:00', 100, '1st';\n",
      "'01/18/2014 13:30:00', 110, '2nd';\n",
      "'01/18/2014 14:00:00', 120, '3rd';\n",
      "\n",
      "[\"'01/18/2014 13:00:00'\", \"'01/18/2014 13:30:00'\", \"'01/18/2014 14:00:00'\"]\n"
     ]
    }
   ],
   "source": [
    "series = \"\"\"\n",
    "'01/18/2014 13:00:00', 100, '1st';\n",
    "'01/18/2014 13:30:00', 110, '2nd';\n",
    "'01/18/2014 14:00:00', 120, '3rd';\n",
    "\"\"\"\n",
    "print(series)\n",
    "\n",
    "dt = re.compile(\"'[0-9/:\\s]+'\")\n",
    "result = dt.findall(series)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string resultante pode ser convertida para objetos do tipo `datetime`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2014-01-18 13:00:00\n",
      "<class 'datetime.datetime'>\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "pydt = datetime.strptime(result[0].replace(\"'\",\"\"), '%m/%d/%Y %H:%M:%S')\n",
    "print(pydt)\n",
    "print(type(pydt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com isso terminamos nossa discusão sobre tipos básicos de dados em python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operações e funções matemáticas básicas\n",
    "\n",
    "\n",
    "Em termos de operações matemáticas simples (soma, subtração, multiplicação e divisão) o python funciona exatamente como uma simples calculadora."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "<class 'int'>\n",
      "30.0\n",
      "<class 'float'>\n",
      "-10\n",
      "<class 'int'>\n",
      "-10.0\n",
      "<class 'float'>\n",
      "1480.0\n",
      "1480.0\n"
     ]
    }
   ],
   "source": [
    "c1 = 10 + 20 # Soma de integer\n",
    "print(c1)\n",
    "print(type(c1))\n",
    "\n",
    "c2 = 10.0 + 20.0 # Soma de float\n",
    "print(c2)\n",
    "print(type(c2))\n",
    "\n",
    "c3 = 10 - 20 # Subtração de integer\n",
    "print(c3)\n",
    "print(type(c3))\n",
    "\n",
    "c4 = 10.0 - 20.0 # Subtração de float\n",
    "print(c4)\n",
    "print(type(c4))\n",
    "\n",
    "c5 = 30*50 + 80/4 - 20*2 # python respeita as operações matemáticas naturais mesmo sem o uso de parenteses.\n",
    "print(c5)\n",
    "\n",
    "# apesar de sempre recomendar o uso dos parenteses para facilitar a leitura de grandes equações\n",
    "c6 = (30*50) + (80/4) - (20*2) \n",
    "print(c6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funções matemáticas especiais como logaritmo, exponencial, potênciação, funções trigonométricas, radiciação entre outras estão disponíveis através do modulo `math`. Ao carregar um modulo em python recomenda-se que apenas as funções que serão usadas sejam carregadas. Por exemplo, no código abaixo queremos calcular o logaritmo, a raiz quadrada, a exponencial e a potência de um número. Desta forma, importamos apenas estas funções do modulo `math`. Uma lista com todas as funções matemáticas disponíveis no modulo `math` pode ser encontrada no endereço (https://www.programiz.com/python-programming/modules/math). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.302585092994046\n",
      "3.1622776601683795\n",
      "1.0\n",
      "100.0\n",
      "1000.0\n"
     ]
    }
   ],
   "source": [
    "from math import log, sqrt, exp, pow\n",
    "\n",
    "print(log(10)) # Logaritmo de 10\n",
    "print(sqrt(10)) # raiz quadrada de 10\n",
    "print(exp(0)) # exponencial\n",
    "print(pow(10, 2)) # 10^2\n",
    "print(pow(10, 3)) # 10^3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estruturas básicas de dados\n",
    "\n",
    "Como uma regra geral, estruturas de dados são objetos que contêm possívelmente um grande número de outros objetos. Entre outros o python oferece as seguintes estruturas de dados:\n",
    "\n",
    "   - `tuple`: Coleção arbitrária de objetos com poucos métodos disponíveis.\n",
    "   - `list`: Coleção arbitrária de objetos com muitos métodos disponíveis.\n",
    "   - `dict`: Objeto que armazenam valores-chaves.\n",
    "   - `set`: Coleção não enumerada de objetos para outros objetos únicos.\n",
    "\n",
    "#### Tuples\n",
    "\n",
    "`tuple` é uma estrutura muito simples e com poucos recursos. A `tuple` é definida através de um conjunto de objetos entre parêntenses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t1 = (1, 2.5, 'tuple')\n",
    "print(type(t1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos selecionar elementos de uma `tuple` através de seus indices. \n",
    "Um aspecto importante é que o python usa zero-based numbering, ou seja, os índices começam em zero.\n",
    "Também podemos selecionar slices da `tuple` através de seus índices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n",
      "1\n",
      "<class 'str'>\n",
      "(1,)\n",
      "(1, 2.5)\n",
      "tuple\n"
     ]
    }
   ],
   "source": [
    "print(t1[1])\n",
    "print(t1[0])\n",
    "print(type(t1[2]))\n",
    "\n",
    "print(t1[0:1]) # Seleciona apenas o elemento na posição 0\n",
    "print(t1[0:2]) # Elemento da posição 0 e 1\n",
    "print(t1[-1]) # Índices negativos tbm funcionam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para objetos do tipo `tuple` existem apenas dois métodos disponíveis: `count` e `index`. O método `count` conta as ocorrências de um certo valor e o método `index` retorno o índice que o valor apareceu pela primeira vez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "t2 = (1,2,2,2,3,3,3,5,5,5,5, \"tuple2\")\n",
    "print(t2.count(5))\n",
    "print(t2.index(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists\n",
    "\n",
    "Objetos do tipo `list` são muito mais flexíveis e poderosos do que `tuple`. Uma `list` é definida através de colchetes (brackets) e em termos de aplicações em estatística serão muito úteis. Entretando, a seleção de elementos e comportamentos básicas são similares aos de uma `tuple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "lista\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2.5, 'lista']\n",
    "print(type(l1))\n",
    "print(l1[2]) # Elemento posição 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também converter objetos do tipo `tuple` para `list` usando a função `list()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "t1 = (1, 2.5, 'tuple')\n",
    "print(type(t1))\n",
    "t1 = list(t1)\n",
    "print(type(t1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objetos do tipo `list` podem ser expandidos e/ou reducidos. Em python essas propriedades definem um objeto `mutable`. Assim, temos que um `list` é `mutable` enquanto que um `tuple` é `immutable`. Vamos ver algumas operações com objetos `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2.5, 'lista', [4, 3]]\n",
      "[1, 2.5, 'lista', [4, 3], 1.0, 1.5, 2.0]\n",
      "[1, 'insert', 2.5, 'lista', [4, 3], 1.0, 1.5, 2.0]\n",
      "[1, 'insert', 2.5, [4, 3], 1.0, 1.5, 2.0]\n",
      "[1, 'insert', 2.5, 1.0, 1.5, 2.0]\n",
      "[4, 3]\n"
     ]
    }
   ],
   "source": [
    "# Acrescenta valores ao fim da list\n",
    "l1.append([4, 3])\n",
    "print(l1)\n",
    "# Extende a list ja existente\n",
    "l1.extend([1.0, 1.5, 2.0])\n",
    "print(l1)\n",
    "# Insere objetos em uma posição especifica\n",
    "l1.insert(1, 'insert')\n",
    "print(l1)\n",
    "# Remove a primeira occorência de um objeto\n",
    "l1.remove('lista')\n",
    "print(l1)\n",
    "# Remove e retorna o objeto em um indice\n",
    "p = l1.pop(3)\n",
    "print(l1)\n",
    "print(p)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing refere-se a operação de quebrar o conjunto de dados em pequenas partes de interesse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.5, 1.0, 1.5]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1[2:5] # Elementos da terceira a quinta posição"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais alguns exemplos de operações com objetos `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'insert', 2.5, 1.0, 1.5, 2.0]\n",
      "[1, 'insert', 5, 1.0, 1.5, 2.0]\n",
      "[1, 'insert', 5, 2, 1, 3, 2.0]\n",
      "1\n",
      "[1, 'insert', 5, 3, 2.0, 10]\n",
      "[1, 'insert', 5, 3, 2.0, 10, 10, 20, 30]\n",
      "[30, 20, 10, 10, 2.0, 3, 5, 'insert', 1]\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-4b12a6d79b79>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0ml1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreverse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Do maior para o menor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0ml1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Do menor para o maior\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "print(l1)\n",
    "l1[2] = 5 # substitui o elemento 3 pelo valor 5\n",
    "print(l1)\n",
    "l1[3:5] = [2,1,3] # Interessante\n",
    "print(l1)\n",
    "l1.append(10) # Junta o 10 na list\n",
    "print(l1.count(10)) # Conta o numero de ocorrência do 10\n",
    "del l1[3:5] # Deleta\n",
    "print(l1)\n",
    "l1.extend([10,20,30])\n",
    "print(l1)\n",
    "l1.reverse() # Do maior para o menor\n",
    "print(l1)\n",
    "l1.sort() # Do menor para o maior\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dicts\n",
    "\n",
    "Objetos do tipo `dict` são dicionários `mutable` e permitem o armazenamento de dados através de `keys` que podem ser por exemplo, `string`. `dict` objetos não são ordenáveis. Um exemplo ilustra melhor a diferença entre `list` e `dict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {\n",
    "    'Nome' : 'Wagner Hugo Bonat',\n",
    "    'País' : 'Brasil',\n",
    "    'Profissão' : 'Professor',\n",
    "    'Idade' : 32\n",
    "}\n",
    "print(type(d))\n",
    "print( d['Nome'], d['Idade'] )\n",
    "\n",
    "d.keys() # Acessa o nome das chaves\n",
    "\n",
    "d.values() # Acessa os valores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem uma séries de métodos para iterar em objetos da classe `dict`. Veremos detalhes na seção de estruturas de controle e programação funcional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sets\n",
    "\n",
    "A última estrutura de dados básica que vamos discutir é a estrutura `set`. A estrutura `set` implementa a teoria dos conjuntos atráves de simples objetos. Ela pode ser útil para explicar conceitos de probabilidade. Vamos ver alguns conceitos simples de probabilidade usando a estrutura `set`em python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set(['A','B', 'AB', 'BA', 'B', 'BA']) # Note que objeto repetidas são automaticamente descartados\n",
    "print(s)\n",
    "t = set(['B', 'BB', 'AA', 'A'])\n",
    "print(t)\n",
    "\n",
    "print(s.union(t)) # União dos conjuntos\n",
    "print(s.intersection(t)) # Intersecção\n",
    "print(s.difference(t)) # Em s mas não em t\n",
    "print(t.difference(s)) # Em t mas não em s\n",
    "print(s.symmetric_difference(t)) # em s ou t mas não em ambos\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estruturas de controle\n",
    "\n",
    "Estruturas de controle são a forma que o programador tem de controlar o que e para quais objetos o código vai funcionar. Apesar de uso geral, nesta seção vou focar mais em objetos do tipo `list`. \n",
    "O exemplo a seguir define uma lista com 6 valores e imprime o quadrado os valores entre os índices 2 e 5. \n",
    "Em python a indentação é parte da linguagem, então observe com atenção os espaços em branco na segunda linha.\n",
    "Note ainda que no segundo loop for o índice teve que ser apropriadamente restrito.\n",
    "Esta estrutura de looping é muito útil e fácil de usar. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2 = [1,2,3,4,5,6]\n",
    "print(l2[2:5])\n",
    "\n",
    "for i in l2[2:5]:\n",
    "    print(l2[i] ** 2)\n",
    "\n",
    "for i in l2:\n",
    "    print(l2[i-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entretando, podemos usar o mais tradicional loop baseado em um contador (como usual em linguagens com C)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(0, 6, 1)\n",
    "\n",
    "for r in range(2, 5):\n",
    "    print(l2[r] ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python também oferece as típicas estruturas de controle condicional `if`, `elif` e `else`. O uso é similar a outras linguagens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 10):\n",
    "    if i % 2 == 0: # % resto da divisão \n",
    "        print(\"%d é par\" % i)\n",
    "    elif i % 3 == 0:\n",
    "        print(\"%d é múltiplo de 3\" % i)\n",
    "    else:\n",
    "        print(\"%d é ímpar\" % i)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O última estrutura de controle que vamos ver será o `while`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "while total < 100:\n",
    "    total += 1\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma especialidade do python é a chamada `list comprehensions`. Ao invés de rodar sobre objetos tipo `list` já existentes, esta abordagem gerá a `list` via loops em uma forma muito compacta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = [i ** 2 for i in range(5)]\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em certo sentido a abordagem de `list comprehensions` já fornece algo como vetorização de código, que será discutida em detalhes na seção Vetorização de código.\n",
    "\n",
    "### Programação funcional\n",
    "\n",
    "Python oferece muitas ferramentas para programação funcional *functional programming*. Programação funcional refere-se ao processo de aplicar uma função a um conjunto de entradas, em geral em python a um objeto do tipo `list`. Entre estas ferramentas estão `filter`, `map` e `reduce`. Entretando, para começar precisamos definir uma função em python. \n",
    "\n",
    "Para começar vamos implementar a distribuição de probabilidade mais usada em estatística, ou seja, a distribuição Gaussiana. A função densidade probabilidade da distribuição Gaussiana é dada por\n",
    "\n",
    "$$ f(y;\\mu, \\sigma^2) = \\frac{1}{\\sqrt{2 \\pi \\sigma^2}} \\exp\\left \\{- \\frac{1}{2\\sigma^2} (y - \\mu)^2 \\right \\}, $$\n",
    "onde $ y, \\mu \\in \\Re$ e $\\sigma^2 > 0$. Nesta parametrização tem-se que $E(Y) = \\mu$ e $Var(Y) = \\sigma^2$.\n",
    "\n",
    "Para implementar tal função em python, primeiro identificamos quais argumentos serão necessários. Neste caso são três $y$, $\\mu$ e $\\sigma^2$. Na sequência identificamos quais as funções matemática especiais envolvidas na função, no caso da distribuição Gaussiana temos, raiz quadrada, constant $\\pi$, potência e exponencial (`sqrt`, `pi`, `pow` e `exp`) todas estão disponíveis através do módulo `math`. Vamos ver como fica a distribuição Gaussiana implementada em python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt, pi, exp, pow\n",
    "\n",
    "def dnorm(y, mu = 0, sigma2 = 1):\n",
    "    output = (1/(sqrt(2 * pi * sigma2)))*exp( - (1/(2 * sigma2)) * pow(y - mu, 2)  )\n",
    "    return output\n",
    "\n",
    "print(dnorm(y = 0))\n",
    "print(dnorm(y = 0, mu = 10, sigma2 = 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponha que queremos aplicar a função `dnorm` para uma `list` de objetos. Podemos fazer isso usando um loop for como na seção anterior. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tradicional loop for\n",
    "numbers = [-3, -2, -1, 0, 1, 2, 3]\n",
    "for i in numbers:\n",
    "    print(dnorm(y = i, mu = 0, sigma2 = 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De uma forma mais elegante podemos usar programação funcional através da função `map` em python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(map(dnorm, numbers)))\n",
    "print(list(map(dnorm, numbers, [10,10,10,10,10,10,10], [1,1,1,1,1,1,1]))) # Um pouco incoveniente mais funciona!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para funções simples (em geral de uma linha) podemos usar funções anônimas ou como são chamadas em python `lambda functions`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(map(lambda x: x ** 2, numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funções também podem ser usadas para filtrar valores de interesse. Suponha que queremos obter apenas os valores pares de uma grande `list` de números. Primeiro definimos a função que faz a seleção e depois aplicamos ela a cada elemento da nossa lista de valores filtrando os que temos interesse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def even(x):\n",
    "    return x % 2 == 0\n",
    "\n",
    "list(filter(even, range(15)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, podemos reduzir o conjunto de dados aplicando alguma função em todos os elementos da `list`. Um exemplo é a soma cumulativa dos objetos em uma `list`. Importante ressaltar que a função `reduce` no python 3.0 é parte do modulo functools, e portante precisa ser importada explicitamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "\n",
    "reduce(lambda x, y: x + y, range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também usar as funções em conjunto ganhando ainda mais flexibilidade. Por exemplo, suponha que queremos somar apenas os números positivos de uma sequência de números em uma `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reduce(lambda x, y: x + y, filter(even, range(20)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É considerado uma boa prática evitar loop for em Python tanto quanto possível. `list comprehension` e `functional programming` atráves de funções como `map`, `filter`  e `reduce` oferecem um código mais compacto e em geral de fácil leitura. \n",
    "\n",
    "### Estrutura de dados NumPy\n",
    "\n",
    "As seções anteriores mostraram que o python oferece algumas estruturas flexíveis para o armazenamento e manipulação de dados básicos. Em particular, `list` são muito úteis para trabalhar com dados e analises estatística. Entretando, quando trabalhando com analise de dados reais, tem-se a necessidade para operações de alta performance em dados com estruturas especiais. Uma das estruturas mais importantes é o `array`. `array` geralmente estruturam outros objetos em linhas e colunas. \n",
    "\n",
    "Assuma que estamos trabalhando com números (os conceitos funcionam também para `string`). No caso mais simples, um `array` unidimensional representa um vetor de números reais representados internamente como `float`. De forma mais geral um `array` representa uma matrix $i \\times j$ de elementos. O mais interessantes sobre `array` é que estes conceitos generalizam para cubos $i \\times j \\times k$ de elementos, bem como, para n-dimensionais arrays de corpo $i \\times j \\times k \\times l \\times, \\ldots$.\n",
    "\n",
    "De forma geral, matrizes são de extrema importância em estatística, assim precisamos de uma forma simples e eficiente de trabalhar ao menos com `arrays` bidimensionais. É neste ponto que a biblioteca `NumPy` é de extrema importância dentro do ambiente python.\n",
    "\n",
    "Antes de introduzir o modelo `NumPy` vamos discutir como `array` podem ser obtidos como uma `list` de `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [0.5, 1, 1.5, 2, 2.5, 3] # vector of numbers\n",
    "m = [v, v, v] # matriz\n",
    "print(m)\n",
    "m[1][0] # Segunda linha primeiro elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também ter um cubo de números, ou um `array` tridimensional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = [0.5, 1.5]\n",
    "v2 = [1, 2]\n",
    "m = [v1,v2]\n",
    "c = [m, m]\n",
    "print(c)\n",
    "print(c[1])\n",
    "print(c[1][0])\n",
    "print(c[1][0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante enfatizar que combinar elementos como feito anteriormente funciona como `reference pointers` para os objetos anteriores. Essa idéia fica clara através de um exemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [0.5, 0.75, 1.0, 1.5, 2.0]\n",
    "m = [v, v, v]\n",
    "print(m)\n",
    "\n",
    "v[0] = 'python'\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para evitar este comportamento usamos a função `deepcopy` do modulo `copy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "v = [0.5, 0.75, 1.0, 1.5, 2.0]\n",
    "m = 3 * [deepcopy(v), ]\n",
    "print(m)\n",
    "v[0] = 'python'\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apesar de flexível esta forma de criar `array` não é muito útil para aplicações em estatística, uma vez que, o ferramental de álgebra linear não está disponível para este tipo de objetos. Por exemplo, a simples multiplicação de um escalar por um vetor não é definida para objetos do tipo `list` em  python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [0.5, 1, 1.5] # vetor\n",
    "n = 2 # escalar\n",
    "n*v # Repete a list duas vezes, ao invés da multiplicação de escalar por vetor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso mostra que precisamos de um tipo de objeto mais especializado que automaticamente entenda operações de álgebra linear e similares. A *library* `NumPy` traz este tipo de objeto que é chamada genericamente de `ndarray`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.array([0, 0.5, 1.0, 1.5, 2.0])\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A principal vantagem deste tipo de objeto é a grande quantidade de métodos disponíveis. Alguns exemplos,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a.sum()) # Soma todos os elementos\n",
    "print(a.std()) # Erro padrão\n",
    "print(a.cumsum()) # Soma acumulada\n",
    "print(a.shape)\n",
    "print(a.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma lista completa de todos os métodos disponíveis para `ndarray` objetos pode ser obtida [aqui](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.ndarray.html). \n",
    "Do ponto de vista de aplicações em estatística a grande vantagem de objetos do tipo `ndarray` é que operações matriciais são reconhecidas. Aqui vamos apresentar apenas o básico, no decorrer da discussão teremos um encontro dedicado especificamente a álgebra linear usando `NumPy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2] # Python basic\n",
    "b = [3, 4]\n",
    "print(a + b) # Concatena\n",
    "\n",
    "a = np.array([1, 2]) # Usando NumPy\n",
    "print(a*2) # Multiplicação por escalar\n",
    "\n",
    "b = np.array([3, 4])\n",
    "print(a + b) # Soma de vetores\n",
    "\n",
    "# Matrix 2 x 2\n",
    "c = np.matrix([ [1,2], [3,4] ])\n",
    "print(c)\n",
    "print(c.shape)\n",
    "\n",
    "c2 = np.matrix([ [4,5], [6, 7]])\n",
    "print(c2[0,:]) # Primeira linha\n",
    "print(c2[:,0]) # Primeira coluna\n",
    "\n",
    "# Multiplicacao de matrizes\n",
    "np.dot(c,c2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma outra especialidade da biblioteca `NumPy` são os `array` estruturados. Essa opção permite que em um mesmo `array` sejam armazenados diferentes tipos de dados por coluna. Porém, vamos deixar esta discussão para um encontro específico."
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}