1-Conceitos-basicos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Atribuição e nomes de variáveis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em python, váriaveis são criadas ao se atribuir um valor a um síbolo válido.\n",
    "Por exemplo, sem atribuir nenhum valor previamente, o seguinte código devolve um erro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'variavelnova' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-16bb8c696d6d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvariavelnova\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'variavelnova' is not defined"
     ]
    }
   ],
   "source": [
    "variavelnova"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note duas coisas: \n",
    "    1. No notebook as células tem como valor da célula o valor da última expressão da célula\n",
    "    2. o erro nos explica o que aconteceu: o nome `variavelnova` não está definido.\n",
    "para definir esse nome, tudo o que precisamos fazer é dar a ele um valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "variavelnova = (2,3)\n",
    "print(variavelnova)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variavelnova"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 2, 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*variavelnova"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python existem diversos tipos de valor que podem ser atribuidos a um nome (ou mais nomes) e veremos alguns deles nesse notebook.\n",
    "Mas primeiro, vejamos o quê python aceita como um nome:\n",
    "  - caracteres ASCII: a-zA-z\n",
    "  - números: 0-9, mas não no primeiro caracter\n",
    "  - underscores: _\n",
    "  - caracteres unicode: β,ç,á,ô... (só de python 3.5 em diante)\n",
    "Podemos descobrir quais nomes são válidos tentando definir váriáves com vários nomes diferentes. Toda vez que recebermos saberemos que aquele nome não é válido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "somenteletrasminúsculas = 1    # note o acento no 'u'. Isso só é possivel em Python 3\n",
    "                               # note que essa célula nã dá um output porque atribuir um nome é uma operação sem valor em Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "LetrasMinusculaEMaiusculas = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "_sobrelinhas__em_varios_lugares = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "______número_noFim10 = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "καρακτηρησ_γρηγωσ = 1   # somente em Python 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-20-cb6927cd9cef>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-20-cb6927cd9cef>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    1numero_no_começo = 1   # não podemos começar um nome com um dígito\u001b[0m\n\u001b[0m                    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "1numero_no_começo = 1   # não podemos começar um nome com um dígito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-21-a0ad5ddbd170>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-21-a0ad5ddbd170>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    nome com espaço = 1   # nomes não podem ter espaços\u001b[0m\n\u001b[0m           ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "nome com espaço = 1   # nomes não podem ter espaços"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-22-c5596260fa77>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-22-c5596260fa77>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    nome_\"com\"+_caracteres-reservados = 1   # não podemos usar carcateres reservados\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "nome_\"com\"+_caracteres-reservados = 1   # não podemos usar carcateres reservados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-23-74071ce3d35c>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-23-74071ce3d35c>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def = 2  # idem acima\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def = 2  # idem acima"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma boa indicação sobre poder usar ou não um caracter ou palavra como nome da variável é a cor atribuída a estes pelo notebook:\n",
    "\n",
    "```python\n",
    "foo = 1\n",
    "@qux\n",
    "def bar(x):\n",
    "    for i in range(10):\n",
    "        print(i)\n",
    "    return\n",
    "print(2 + 3)\n",
    "print(\"foo!\")\n",
    "```\n",
    "\n",
    "Note que os erros acima ocorreram quando tentamos dar um valor à uma palavra com cor destacada, como verde ou roxo.\n",
    "Não necessáriamente os nomes são de cor preta, mas quando não são é muito provável que estejamos dando um novo valor a uma variável definida pela linguagem (uma função builtin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    return list(range(10))\n",
    "\n",
    "def bar():\n",
    "    list = 1\n",
    "    return list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-226d01f48125>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-25-d63fdddaa30f>\u001b[0m in \u001b[0;36mbar\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mbar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mlist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not callable"
     ]
    }
   ],
   "source": [
    "bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além de como escolhemos os nomes, podemos fazer \"atribuições destrutivas\", ou seja darmos nomes a pedaços dos valores atribuídos.\n",
    "Essa característica da sintáxe é muito útil quando lidamos com listas e outras estruturas de dados mais complexas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = 1,2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:46:12.816877Z",
     "start_time": "2017-07-18T17:46:12.803301Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 7 8 9 10 12 13\n"
     ]
    }
   ],
   "source": [
    "# atribuição \n",
    "a = 1 \n",
    "\n",
    "b,c,d = 2,3,4  # múltiplas atribuições por linha\n",
    "\n",
    "e, _, f = [5,6,7]  # múltiplas atrubuições - destruição de estrutura ou pattern matching\n",
    "\n",
    "(g,h),(i,(_,j),k) = {(8,9),(10,(11,12),13)}  # destruição em padrões não triviais\n",
    "\n",
    "print(a,b,c,d,f,g,h,i,j,k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como dito acima no notebook, o último valor de uma célula é valor da célula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:23:34.240981Z",
     "start_time": "2017-07-18T15:23:34.234441Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 3\n",
    "a = 2*b\n",
    "1 + 1 == 2\n",
    "2 * 3 == 6\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:28:14.468132Z",
     "start_time": "2017-07-18T15:28:14.463021Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# print (e diversas outras funções ou elementos da sintáxe) não devolve valor\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos em Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Números e aritmética\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "602"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b001\n",
    "0x25a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Números são representados de algumas formas em python:\n",
    "  - Inteiros são representados pelos dígitos que os formam:\n",
    "  ```python\n",
    "1\n",
    "123\n",
    "937571901037471038471\n",
    "```\n",
    "  - Reais são representados por ponto flutuante, como em outras linguagens, ou com notação científica:\n",
    "  ```python\n",
    "1.2\n",
    "2017854.5971365\n",
    "1.23e10\n",
    "108365.28717E19\n",
    "```\n",
    "  - Complexos são pontos flutuantes escritos da seguinte forma:\n",
    "  ```python\n",
    "1.2 + 2j\n",
    "complex(1.2,2)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "Operações elementares com números:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:19:16.850226Z",
     "start_time": "2017-07-18T15:19:16.827819Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# soma\n",
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:00:02.533563Z",
     "start_time": "2017-07-18T16:00:02.527747Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subtração\n",
    "2 - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:19:22.557190Z",
     "start_time": "2017-07-18T15:19:22.550946Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# produto\n",
    "2 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:19:26.428523Z",
     "start_time": "2017-07-18T15:19:26.423475Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# potência\n",
    "2 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:19:33.854835Z",
     "start_time": "2017-07-18T15:19:33.848472Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# divisão real\n",
    "3 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:20:29.516130Z",
     "start_time": "2017-07-18T15:20:29.509572Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# divisão inteira\n",
    "5 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:21:34.469554Z",
     "start_time": "2017-07-18T15:21:34.463327Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# módulo da divisão inteira\n",
    "5 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:21:40.723038Z",
     "start_time": "2017-07-18T15:21:40.718493Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# valor absoluto\n",
    "abs(-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:48:56.720953Z",
     "start_time": "2017-07-18T15:48:56.714675Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.23512 150000000.0 1.26e-05\n",
      "0.5\n",
      "0.0009765625\n",
      "0.9330329915368074\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "# ponto flutuante\n",
    "print(1.23512, 1.5E8, 1.26e-5)\n",
    "print(1/2)\n",
    "print(0.5**10)\n",
    "print(0.5**(1/10))\n",
    "print(3.0 + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Booleanos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:21:04.726554Z",
     "start_time": "2017-07-18T15:21:04.721540Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# igualdade\n",
    "1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T15:21:06.280574Z",
     "start_time": "2017-07-18T15:21:06.274647Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diferença\n",
    "1 != 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:00:24.039185Z",
     "start_time": "2017-07-18T16:00:24.030436Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True and True =  True\n",
      "True and False =  False\n",
      "False and True =  False\n",
      "False and False =  False\n"
     ]
    }
   ],
   "source": [
    "# tabela verdade do operador E\n",
    "for (a,b) in [(True,True), (True,False), (False,True), (False,False)]:\n",
    "    print(f\"{a} and {b} = \", a and b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:00:35.367788Z",
     "start_time": "2017-07-18T16:00:35.358687Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True or True =  True\n",
      "True or False =  True\n",
      "False or True =  True\n",
      "False or False =  False\n"
     ]
    }
   ],
   "source": [
    "# tabela verdade do operador OU\n",
    "for a,b in zip([True, True, False, False], [True, False, True, False]):\n",
    "    print(f\"{a} or {b} = \", a or b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2 <= 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False, True, False)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2, 1 > 2, 1 <= 1, 1 >= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"foo\" > \"quxes\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'>' not supported between instances of 'tuple' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-68-ca9f3f4b5c22>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '>' not supported between instances of 'tuple' and 'list'"
     ]
    }
   ],
   "source": [
    "(2,3) > [1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:01:56.429607Z",
     "start_time": "2017-07-18T16:01:56.423925Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'foo bar baz'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strings podem ser criadas com aspas duplas\n",
    "\"foo bar baz\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:02:01.539541Z",
     "start_time": "2017-07-18T16:02:01.532367Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'foo bar baz'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ou aspas simples\n",
    "'foo bar baz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:02:45.518339Z",
     "start_time": "2017-07-18T16:02:45.511784Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "foo     bar\n",
      "\n",
      "baz\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# strings com 3 aspas (duplas ou simples) mantém os espaços\n",
    "foo = \"\"\"\n",
    "\n",
    "foo     bar\n",
    "\n",
    "baz\n",
    "\"\"\"\n",
    "print(foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "Python não tem um \"tipo Char\", todo caracter entre aspas é uma string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:03:23.502377Z",
     "start_time": "2017-07-18T16:03:23.495637Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'foobar'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenando strings\n",
    "\"foo\" + \"bar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:05:03.268306Z",
     "start_time": "2017-07-18T16:05:03.263109Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foo', 'bar', 'baz']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# quebrando uma string com uma substring\n",
    "\"foo, bar, baz\".split(', ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:05:20.328334Z",
     "start_time": "2017-07-18T16:05:20.321728Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'foo _ bar _ baz'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# unindo strings uma substring\n",
    "' _ '.join(['foo', 'bar', 'baz'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:06:10.949700Z",
     "start_time": "2017-07-18T16:06:10.943410Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "This is a number: 1\n",
      "This is a string: foo\n",
      "This is a tuple: (1, 'bar')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# estilo python de formatar strings\n",
    "print(\"\"\"\n",
    "This is a number: {}\n",
    "This is a string: {}\n",
    "This is a tuple: {}\n",
    "\"\"\".format(1,\"foo\", (1,'bar')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:07:24.594260Z",
     "start_time": "2017-07-18T16:07:24.586823Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "This is a number: 1\n",
      "This is a string: foo\n",
      "This is a tuple: (1,'bar')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# estilo C de formatar strings\n",
    "print(\"\"\"\n",
    "This is a number: %d\n",
    "This is a string: %s\n",
    "This is a tuple: (%d,'%s')\n",
    "\"\"\" % (1,\"foo\", 1, 'bar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T16:12:27.603333Z",
     "start_time": "2017-07-18T16:12:27.593187Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "This is a number: 1\n",
      "This is a string: foo\n",
      "This is a tuple: (1, 'bar')\n"
     ]
    }
   ],
   "source": [
    "# estilo python 3.6 de formatar strings\n",
    "a = 1\n",
    "b = 'foo'\n",
    "c = (1,'bar')\n",
    "print(f\"\"\"\n",
    "This is a number: {a}\n",
    "This is a string: {b}\n",
    "This is a tuple: {c}\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-17T18:46:15.078145Z",
     "start_time": "2017-07-17T18:46:15.068135Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1 = IEI!, var2 = 123456\n",
      "var1 = IEI!, var2 = 123456\n",
      "var1 = IEI!, var2 = 123456\n"
     ]
    }
   ],
   "source": [
    "variavel1 = \"IEI!\"\n",
    "variavel2 = 123456\n",
    "print(f\"var1 = {variavel1}, var2 = {variavel2}\")\n",
    "print(\"var1 = {x}, var2 = {y}\".format(x=variavel1,y=variavel2))\n",
    "print(\"var1 = %s, var2 = %d\"%(variavel1, variavel2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "## Listas, Tuplas, Dicionários e Conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas em Python são estruturas de dados mutáveis que podem conter qualquer número de elementos de quaisquer tipos, possivelmente distintos.\n",
    "\n",
    "Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:24:03.330821Z",
     "start_time": "2017-07-18T17:24:03.316438Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "\n",
      "2.5\n",
      "\n",
      "foo\n",
      "\n",
      "True\n",
      "\n",
      "[1, 2, 3, 4]\n",
      "\n",
      "('f', 1, 10)\n",
      "\n",
      "{'a': 2, 'b': 3}\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2.5, 'foo', True, [1, 2, 3, 4], ('f', 1, 10), {'a': 2, 'b': 3}]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1,2.5,'foo',True,[1,2,3,4],('f',1,10),{'a':2,'b':3}]\n",
    "print(*lista, sep='\\n\\n',end='\\n\\n')\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar elementos de uma lista, lembre-se que os índices são inteiros começandio em zero e terminando em $n-1$, onde $n$ é o número de elementos na lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:26.203766Z",
     "start_time": "2017-07-18T17:43:26.189440Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 3)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2,3,4,5]\n",
    "n = len(a)\n",
    "a[0], a[n-1], a[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e podemos acessar em ordem inversa com números negativos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:27.040556Z",
     "start_time": "2017-07-18T17:43:27.034718Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 4, 3)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-1],a[-2],a[-3]  # esperamos (5,4,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para adicionar um elemento no fim de uma lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:29.261456Z",
     "start_time": "2017-07-18T17:43:29.253833Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.append(6)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:29.261456Z",
     "start_time": "2017-07-18T17:43:29.253833Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 'foo']"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.append(\"foo\")\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou numa posição arbitrária:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:29.749791Z",
     "start_time": "2017-07-18T17:43:29.742830Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 'foo']"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.insert(0,0)\n",
    "a  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e para remover um elemento pelo valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:31.708697Z",
     "start_time": "2017-07-18T17:43:31.703828Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 4, 5, 6, 'foo']"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.remove(3)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:31:32.301576Z",
     "start_time": "2017-07-18T17:31:32.293986Z"
    }
   },
   "source": [
    "ou usan o índice e guardando o valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:32.400438Z",
     "start_time": "2017-07-18T17:43:32.393417Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'foo'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:33.124188Z",
     "start_time": "2017-07-18T17:43:33.117119Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 4, 6]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listas podem ser concatenadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:35.634538Z",
     "start_time": "2017-07-18T17:43:35.625628Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2]\n",
    "b = [3,4]\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e podem ser repetidas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:36.832772Z",
     "start_time": "2017-07-18T17:43:36.826737Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 1, 2, 1, 2, 1, 2]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4*a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qualquer valor de uma lista pode ser alterado. Basta fazer uma atribuição:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:39.171038Z",
     "start_time": "2017-07-18T17:43:39.165171Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 2]\n",
      "[10, 2]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a[0] = 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operações aritméticas podem ser feitas \"in place\" (sem alocação de memória extra) em listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:40.025627Z",
     "start_time": "2017-07-18T17:43:40.011569Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 2]\n",
      "[11, 2]\n",
      "[22, 2]\n",
      "[7.333333333333333, 2]\n"
     ]
    }
   ],
   "source": [
    "print(a, end='\\n')\n",
    "a[0] += 1  # a[0] = a[0] + 1\n",
    "print(a, end='\\n')\n",
    "a[0] *= 2\n",
    "print(a, end='\\n')\n",
    "a[0] /= 3\n",
    "print(a, end='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuplas são parecidas com listas, mas uma vez criadas não podem ser modificadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:43.767059Z",
     "start_time": "2017-07-18T17:43:43.760281Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2.5, 'foo', [1, 2, 3, 4])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla = (1,2.5,'foo',[1,2,3,4])\n",
    "tupla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acesso aos elementos é igual a listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:43:56.191155Z",
     "start_time": "2017-07-18T17:43:56.185011Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, [1, 2, 3, 4], 4)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla[0], tupla[-1], len(tupla)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Não é possível alterar uma tupla depois de criada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T17:47:09.336108Z",
     "start_time": "2017-07-18T17:47:09.316105Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-103-5e080b70ef1b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a = (1,2)\n",
    "a[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-104-4ff8a30e1c5e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "a.append(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicionários"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dicionários são a estrutura de dados mais importante em Python, dado que todo o sistema de classes e objetos é construído usando dicionários.\n",
    "Dicionários são, em essência, uma lista de tuplas, cada tupla com dois elementos sendo o primeiro uma \"chave\" e o segundo um \"valor\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:01:54.232107Z",
     "start_time": "2017-07-18T18:01:54.221840Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': (1, 2, 3), (2, 'c'): 'foo', 10: [5, 6, 7, 8]}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dicionario = {'a':1, 'b':(1,2,3), (2,'c'):'foo', 10:[5,6,7,8]}\n",
    "dicionario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "outra forma de construir dicionários é chamando a função ´dict´"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:01:55.053391Z",
     "start_time": "2017-07-18T18:01:55.045133Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': (1, 2, 3), 'c': 'bar'}"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(a=1, b=(1,2,3),c='bar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acesso a elementos é feito usando as chaves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:01:55.625941Z",
     "start_time": "2017-07-18T18:01:55.619281Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, [5, 6, 7, 8])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dicionario['a'], dicionario[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inserção de elemntos é simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:01:56.767867Z",
     "start_time": "2017-07-18T18:01:56.759059Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1,\n",
       " 'b': (1, 2, 3),\n",
       " (2, 'c'): 'foo',\n",
       " 10: [5, 6, 7, 8],\n",
       " 'bar': 12878934175091}"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dicionario['bar'] = 12878934175091\n",
    "dicionario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "recuperar todas as chaves, todos os valores ou todas as duplas de chave e valor também:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:01:58.703704Z",
     "start_time": "2017-07-18T18:01:58.695409Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['b', (2, 'c'), 10])\n",
      "\n",
      "dict_values([(1, 2, 3), 'foo', [5, 6, 7, 8]])\n",
      "\n",
      "dict_items([('b', (1, 2, 3)), ((2, 'c'), 'foo'), (10, [5, 6, 7, 8])])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(dicionario.keys(),end='\\n\\n')\n",
    "print(dicionario.values(),end='\\n\\n')\n",
    "print(dicionario.items(),end='\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Items podem ser removidos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:02:00.139331Z",
     "start_time": "2017-07-18T18:02:00.131315Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(10, [5, 6, 7, 8])\n",
      "{'b': (1, 2, 3), (2, 'c'): 'foo'}\n"
     ]
    }
   ],
   "source": [
    "print(dicionario.pop('a'))\n",
    "print(dicionario.popitem())\n",
    "print(dicionario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e podem ser criados a partir de outros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:04:09.447514Z",
     "start_time": "2017-07-18T18:04:09.439024Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b': None, (2, 'c'): None}"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = dict.fromkeys(dicionario.keys())\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:04:25.286954Z",
     "start_time": "2017-07-18T18:04:25.279177Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b': (1, 2, 3), (2, 'c'): 'foo'}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.update(dicionario)\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:04:43.571823Z",
     "start_time": "2017-07-18T18:04:43.563359Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b': (1, 2, 3), (2, 'c'): 'foo', 'iei': range(0, 10)}"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.update({'iei':range(10)})\n",
    "foo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conjuntos são containers não ordenados, em que os elementos são únicos. Além disso, as operações elementares de conjuntos podem ser aplicadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:07:23.335357Z",
     "start_time": "2017-07-18T18:07:23.319604Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({1, 2, 3}, {2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6, 7})"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = {1,2,3}\n",
    "b = {2,3,4,5,6}\n",
    "c = set([1,1,1,1,1,2,3,4,4,4,4,5,3,1,4,1,6,7,2,6,1,4,6,2,3])\n",
    "a, b, c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:06:32.221738Z",
     "start_time": "2017-07-18T18:06:32.215550Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({1, 2, 3, 4, 5, 6}, {2, 3})"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.union(b), a.intersection(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:06:46.834343Z",
     "start_time": "2017-07-18T18:06:46.828095Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({1}, {4, 5, 6})"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.difference(b), b.difference(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A maior utilidade de conjuntos é carantir unicidade de elementos, e (provavelmente) não os usaremos até o fim do curso, mas é bom lembrar que existem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Controle de fluxo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If, elif, else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para testar condições em python usamos construções do tipo\n",
    "\n",
    "```python\n",
    "if condition:\n",
    "    do_stuff()\n",
    "elif other_condition:\n",
    "    do_other_stuff()\n",
    "elif ...:\n",
    ".\n",
    ".\n",
    ".\n",
    "else:  # nenhuma condição anterior foi satisfeita\n",
    "    do_remaining_stuff()\n",
    "```\n",
    "\n",
    "Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:14:36.715004Z",
     "start_time": "2017-07-18T18:14:36.693485Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n"
     ]
    }
   ],
   "source": [
    "a, b = 10, 20\n",
    "if a < b:\n",
    "    print('A')\n",
    "elif a == b:\n",
    "    print('A or B')\n",
    "else:\n",
    "    print('B')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que não é necessário usar booleanos nas condições"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:16:13.664749Z",
     "start_time": "2017-07-18T18:16:13.658742Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Números são considerados \"True\"...\n",
      "mesmo os negativos\n"
     ]
    }
   ],
   "source": [
    "if 10:\n",
    "    print('Números são considerados \"True\"...')\n",
    "if -10:\n",
    "    print('mesmo os negativos')\n",
    "if 0:\n",
    "    print('mas não o zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:17:30.813879Z",
     "start_time": "2017-07-18T18:17:30.806609Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Listas não vazias são \"True\"\n",
      "Listas vazias são \"False\"\n"
     ]
    }
   ],
   "source": [
    "if [1,2,3]:\n",
    "    print('Listas não vazias são \"True\"')\n",
    "if not []:\n",
    "    print('Listas vazias são \"False\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O mesmo vale para tuplas, dicionários e conjuntos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:18:39.430004Z",
     "start_time": "2017-07-18T18:18:39.418409Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings não vazias também são \"True\"...\n",
      "mas Strings vazies são \"False\"\n"
     ]
    }
   ],
   "source": [
    "if 'foo':\n",
    "    print('Strings não vazias também são \"True\"...')\n",
    "if not '':\n",
    "    print('mas Strings vazies são \"False\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while e for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para iterar sobre containers ou sequências, usamos as estruturas de `while` ou `for`:\n",
    "\n",
    "```python\n",
    "while condition:\n",
    "    dostuff()\n",
    "    controlcondition()\n",
    "\n",
    "for element in container:\n",
    "    dostuff()\n",
    "```\n",
    "\n",
    "Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:21:26.363704Z",
     "start_time": "2017-07-18T18:21:26.354640Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "while n > 0:\n",
    "    print(n)\n",
    "    n -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('b', (1, 2, 3)), ((2, 'c'), 'foo')])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dicionario.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0.0)\n",
      "(1, 3.0)\n",
      "(2, 6.82842712474619)\n",
      "(3, 11.196152422706632)\n",
      "(4, 16.0)\n",
      "(5, 21.18033988749895)\n",
      "(6, 26.69693845669907)\n",
      "(7, 32.52025917745213)\n",
      "(8, 38.62741699796952)\n",
      "(9, 45.0)\n"
     ]
    }
   ],
   "source": [
    "for y in [(x, 2*x + numpy.sqrt(x**3)) for x in range(10)]:\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for n in range(10,0,-1):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:21:48.644766Z",
     "start_time": "2017-07-18T18:21:48.636643Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "\n",
      "(1, 2, 3)\n",
      "(2, 'c')\n",
      "\n",
      "foo\n"
     ]
    }
   ],
   "source": [
    "for (k, v) in dicionario.items():\n",
    "    print(k, v, sep='\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formas compactas de iterar sobre objectos são chamadas _comprehension_ (compreensão) e podem ser usadas em listas, dicionários ou conjuntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:23:39.490775Z",
     "start_time": "2017-07-18T18:23:39.481357Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 8, 27, 64, 125, 216, 343, 512, 729}"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i**3 for i in range(10)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:23:56.478502Z",
     "start_time": "2017-07-18T18:23:56.470645Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i**2 for i in range(10) if i**2 % 2 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:24:07.931914Z",
     "start_time": "2017-07-18T18:24:07.925398Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i:i**2 for i in range(10)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para tuplas, existe uma pegadinha. \n",
    "Se você tentar o intuitivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:24:47.051755Z",
     "start_time": "2017-07-18T18:24:47.044811Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "for x in (i**2 for i in range(10)):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você obtem um gerador, que pode ser visto como uma lista preguiçosa que ainda não está na memória (cada elemento será colocado na memória quando for requisitado).\n",
    "\n",
    "Para obter uma tupla é preciso usar a função `tuple`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:26:12.307533Z",
     "start_time": "2017-07-18T18:26:12.300905Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(i**2 for i in range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos combinar condicionais na compreensão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:27:22.066510Z",
     "start_time": "2017-07-18T18:27:22.057760Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for i in range(100) if i%10 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou encadear vários indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:27:56.629126Z",
     "start_time": "2017-07-18T18:27:56.619961Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0),\n",
       " (0, 1),\n",
       " (0, 2),\n",
       " (0, 3),\n",
       " (1, 0),\n",
       " (1, 1),\n",
       " (1, 2),\n",
       " (1, 3),\n",
       " (2, 0),\n",
       " (2, 1),\n",
       " (2, 2),\n",
       " (2, 3)]"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(i,j) for i in range(3) for j in range(4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou ambos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:28:45.168135Z",
     "start_time": "2017-07-18T18:28:45.158951Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0),\n",
       " (0, 10),\n",
       " (0, 20),\n",
       " (0, 30),\n",
       " (10, 0),\n",
       " (10, 10),\n",
       " (10, 20),\n",
       " (10, 30),\n",
       " (20, 0),\n",
       " (20, 10),\n",
       " (20, 20),\n",
       " (20, 30)]"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(i, j) for i in range(30) if i%10==0 for j in range(40) if j%10==0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funções são definidas usando a construção:\n",
    "\n",
    "```python\n",
    "def nome_da_funcao(var_1, var_2=default2, *possivelmente_infinitas_vars, kwvar1, kwvar2=defaultkwvar2,**possivelemente_infinitas_kwvars):\n",
    "    comando_1\n",
    "    comando_2\n",
    "    ...\n",
    "    (return algo)?\n",
    "```\n",
    "\n",
    "e aplicar\n",
    "\n",
    "por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:33:08.468426Z",
     "start_time": "2017-07-18T18:33:08.459657Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,  {'a': 12351}\n"
     ]
    }
   ],
   "source": [
    "def hello(nome):\n",
    "    print('Hello, ', nome)\n",
    "    \n",
    "hello({'a':12351})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:34:18.557876Z",
     "start_time": "2017-07-18T18:34:18.541759Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 1.2\n",
      "1.0 1.2\n",
      "1.0 1.2\n",
      "3 4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1, 3, 45, 3)"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def soma(n1, n2=0, *outros, a=1.0, b=1.2):\n",
    "    s = n1 + n2\n",
    "    for n in outros:\n",
    "        s += n\n",
    "    print(a,b)\n",
    "    return s\n",
    "\n",
    "soma(1), soma(1,2), soma(1,2,3,4,5,6,7,8,9), soma(1,2,a=3,b=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "em Python,funções podem ser passadas como valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:36:10.842311Z",
     "start_time": "2017-07-18T18:36:10.834543Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n",
      "1.0 1.2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for f in [abs, str, soma]:\n",
    "    print(f(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e existem funções anônimas (lambda):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-18T18:36:45.679553Z",
     "start_time": "2017-07-18T18:36:45.672298Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x: x%2==0, [1,2,3,4,5,6,7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aspectos do paradigma de Orientação à Objeto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, tudo é um objeto (exceto palavras chave e carcteres reservados da sintáxe).\n",
    "Um objecto contém atributos e métodos que contam como esse objeto interage com outros.\n",
    "\n",
    "Note que nos explos acima, algumas vezes aparecem coisas como\n",
    "```python\n",
    "\" _ \".join([\"foo\",\"bar\"])\n",
    "```\n",
    "ou seja, temos um objecto `\" _ \"` seguido de um ponto `.` seguido de uma função sendo chamada com outros valores.\n",
    "Esse ponto `.` é a sintáxe de Python para acessar os atributos e métodos de um objeto.\n",
    "Lembre-se que tudo em Python é um objeto e portanto, usando essa sintáxe e o autocompletamento que o notebook fornece, é possível descobrir muita coisa que se pode fazer com um objeto.\n",
    "\n",
    "Note, porém, que o ponto `.` entra em conflito com a notação do números e, algumas vezes, com outros aspectos do ambiente.\n",
    "Quando o autocompletamento não ajudar, tente \"subir\" na hierarquia de nomes, por exemplo pedindo o tipo do valor para o qual quer descobrir o que pode fazer e tentar o completamento para o tipo (afinal, se tudo em Python são objetos, tipos de váriáves também são objetos):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# coloque o cursor depois do ponto e aperte tab\n",
    "int.conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# idem\n",
    "str. "
   ]
  }
 ],
 "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.6.4"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "85px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}