02-python-oo/aula-03/Aula 03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Py-OO] Aula 03\n",
    "\n",
    "## Modelo de dados do Python\n",
    "\n",
    "O que você vai aprender nesta aula?\n",
    "\n",
    "Após o término da aula você terá aprendido:\n",
    "\n",
    "- O que é o modelo de dados do Python\n",
    "- Para que servem e como funcionam métodos mágicos\n",
    "- Protocolos em Python\n",
    "    - Sequência\n",
    "- Sobrecarga de operadores\n",
    "- Duck Typing\n",
    "\n",
    "*Este material usou o Capítulo 1 (Modelo de dados do Python) do livro Python Fluente do Luciano Ramalho*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Nesta aula vamos falar sobre como funciona o modelo de dados do Python.\n",
    "\n",
    "O Python é uma linguagem conhecida por sua consistência. Isso permite que, após trabalhar certo tempo com a linguagem, você consiga ter palpiters corretos sobre recursos do Python que você ainda não domina.\n",
    "\n",
    "Um exemplo da consistência da linguagem se dá pela função `len()`, que apesar de parecer estranho de se usar - `len(collection)` ao invés de `collection.len()` como é feito em outras linguagens - sabemos, conforme visto no curso, que podemos usá-la para **qualquer** coleção, enquanto outras linguagens possuem métodos de nomes diferentes para realizar essa mesma operação.\n",
    "\n",
    "O responsável por consistência (e estranheza) é o Python data model (modelo de dados do Python) que descreve a API que pode ser usada para fazer que seus próprios objetos interajam bem com os recursos mais idiomáticos da linguagem. Ele descreve os objetos e como estes interagem entre si.\n",
    "\n",
    "O modelo de dados formaliza as interfaces dos blocos de construção da própria linguagem, por exemplo, as sequências, os iteradores, as funções, as classes, os gerenciadores de contexto e assim por diante.\n",
    "\n",
    "O python faz isso usando os métodos especiais: o interpretador do Python chama esses métodos para realizar operações básicas em objetos, geralmente acionados por uma sintaxe especial.\n",
    "\n",
    "Os métodos especiais são sempre escritos com underscores duplos no início e no fim (como `__getitem__`). Por exemplo a sintaxe especial `obj[chave]` é tratada pelo método especial `__getitem__`. Quando o interpretador avalia `colecao[chave]` ele chama `colecao.__getitem__(chave)`.\n",
    "\n",
    "Vamos mostrar um exemplo de como podemos usar o modelo de dados do python a nosso favor. Vamos criar um baralho pythônico:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from exemplos.baralho import Baralho\n",
    "\n",
    "baralho = Baralho()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acessar as cartas do baralho por índice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Carta(valor='2', naipe='copas')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "baralho[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Carta(valor='K', naipe='espadas')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "baralho[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos realizar slicing no baralho:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Carta(valor='2', naipe='copas'),\n",
       " Carta(valor='2', naipe='ouros'),\n",
       " Carta(valor='2', naipe='paus'),\n",
       " Carta(valor='2', naipe='espadas'),\n",
       " Carta(valor='3', naipe='copas')]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "baralho[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Carta(valor='5', naipe='espadas'),\n",
       " Carta(valor='6', naipe='copas'),\n",
       " Carta(valor='6', naipe='ouros'),\n",
       " Carta(valor='6', naipe='paus'),\n",
       " Carta(valor='6', naipe='espadas')]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "baralho[15:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Carta(valor='Q', naipe='espadas'),\n",
       " Carta(valor='K', naipe='copas'),\n",
       " Carta(valor='K', naipe='ouros'),\n",
       " Carta(valor='K', naipe='paus'),\n",
       " Carta(valor='K', naipe='espadas')]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "baralho[-5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E iterá-lo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Carta(valor='2', naipe='copas')\n",
      "Carta(valor='2', naipe='ouros')\n",
      "Carta(valor='2', naipe='paus')\n",
      "Carta(valor='2', naipe='espadas')\n",
      "Carta(valor='3', naipe='copas')\n",
      "Carta(valor='3', naipe='ouros')\n",
      "Carta(valor='3', naipe='paus')\n",
      "Carta(valor='3', naipe='espadas')\n",
      "Carta(valor='4', naipe='copas')\n",
      "Carta(valor='4', naipe='ouros')\n",
      "Carta(valor='4', naipe='paus')\n",
      "Carta(valor='4', naipe='espadas')\n",
      "Carta(valor='5', naipe='copas')\n",
      "Carta(valor='5', naipe='ouros')\n",
      "Carta(valor='5', naipe='paus')\n",
      "Carta(valor='5', naipe='espadas')\n",
      "Carta(valor='6', naipe='copas')\n",
      "Carta(valor='6', naipe='ouros')\n",
      "Carta(valor='6', naipe='paus')\n",
      "Carta(valor='6', naipe='espadas')\n",
      "Carta(valor='7', naipe='copas')\n",
      "Carta(valor='7', naipe='ouros')\n",
      "Carta(valor='7', naipe='paus')\n",
      "Carta(valor='7', naipe='espadas')\n",
      "Carta(valor='8', naipe='copas')\n",
      "Carta(valor='8', naipe='ouros')\n",
      "Carta(valor='8', naipe='paus')\n",
      "Carta(valor='8', naipe='espadas')\n",
      "Carta(valor='9', naipe='copas')\n",
      "Carta(valor='9', naipe='ouros')\n",
      "Carta(valor='9', naipe='paus')\n",
      "Carta(valor='9', naipe='espadas')\n",
      "Carta(valor='10', naipe='copas')\n",
      "Carta(valor='10', naipe='ouros')\n",
      "Carta(valor='10', naipe='paus')\n",
      "Carta(valor='10', naipe='espadas')\n",
      "Carta(valor='A', naipe='copas')\n",
      "Carta(valor='A', naipe='ouros')\n",
      "Carta(valor='A', naipe='paus')\n",
      "Carta(valor='A', naipe='espadas')\n",
      "Carta(valor='J', naipe='copas')\n",
      "Carta(valor='J', naipe='ouros')\n",
      "Carta(valor='J', naipe='paus')\n",
      "Carta(valor='J', naipe='espadas')\n",
      "Carta(valor='Q', naipe='copas')\n",
      "Carta(valor='Q', naipe='ouros')\n",
      "Carta(valor='Q', naipe='paus')\n",
      "Carta(valor='Q', naipe='espadas')\n",
      "Carta(valor='K', naipe='copas')\n",
      "Carta(valor='K', naipe='ouros')\n",
      "Carta(valor='K', naipe='paus')\n",
      "Carta(valor='K', naipe='espadas')\n"
     ]
    }
   ],
   "source": [
    "for carta in baralho:\n",
    "    print(carta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterá-lo de trás para frente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Carta(valor='K', naipe='espadas')\n",
      "Carta(valor='K', naipe='paus')\n",
      "Carta(valor='K', naipe='ouros')\n",
      "Carta(valor='K', naipe='copas')\n",
      "Carta(valor='Q', naipe='espadas')\n",
      "Carta(valor='Q', naipe='paus')\n",
      "Carta(valor='Q', naipe='ouros')\n",
      "Carta(valor='Q', naipe='copas')\n",
      "Carta(valor='J', naipe='espadas')\n",
      "Carta(valor='J', naipe='paus')\n",
      "Carta(valor='J', naipe='ouros')\n",
      "Carta(valor='J', naipe='copas')\n",
      "Carta(valor='A', naipe='espadas')\n",
      "Carta(valor='A', naipe='paus')\n",
      "Carta(valor='A', naipe='ouros')\n",
      "Carta(valor='A', naipe='copas')\n",
      "Carta(valor='10', naipe='espadas')\n",
      "Carta(valor='10', naipe='paus')\n",
      "Carta(valor='10', naipe='ouros')\n",
      "Carta(valor='10', naipe='copas')\n",
      "Carta(valor='9', naipe='espadas')\n",
      "Carta(valor='9', naipe='paus')\n",
      "Carta(valor='9', naipe='ouros')\n",
      "Carta(valor='9', naipe='copas')\n",
      "Carta(valor='8', naipe='espadas')\n",
      "Carta(valor='8', naipe='paus')\n",
      "Carta(valor='8', naipe='ouros')\n",
      "Carta(valor='8', naipe='copas')\n",
      "Carta(valor='7', naipe='espadas')\n",
      "Carta(valor='7', naipe='paus')\n",
      "Carta(valor='7', naipe='ouros')\n",
      "Carta(valor='7', naipe='copas')\n",
      "Carta(valor='6', naipe='espadas')\n",
      "Carta(valor='6', naipe='paus')\n",
      "Carta(valor='6', naipe='ouros')\n",
      "Carta(valor='6', naipe='copas')\n",
      "Carta(valor='5', naipe='espadas')\n",
      "Carta(valor='5', naipe='paus')\n",
      "Carta(valor='5', naipe='ouros')\n",
      "Carta(valor='5', naipe='copas')\n",
      "Carta(valor='4', naipe='espadas')\n",
      "Carta(valor='4', naipe='paus')\n",
      "Carta(valor='4', naipe='ouros')\n",
      "Carta(valor='4', naipe='copas')\n",
      "Carta(valor='3', naipe='espadas')\n",
      "Carta(valor='3', naipe='paus')\n",
      "Carta(valor='3', naipe='ouros')\n",
      "Carta(valor='3', naipe='copas')\n",
      "Carta(valor='2', naipe='espadas')\n",
      "Carta(valor='2', naipe='paus')\n",
      "Carta(valor='2', naipe='ouros')\n",
      "Carta(valor='2', naipe='copas')\n"
     ]
    }
   ],
   "source": [
    "for carta in reversed(baralho):\n",
    "    print(carta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enumerá-lo!!!111!!!onze!!11!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, Carta(valor='2', naipe='copas'))\n",
      "(1, Carta(valor='2', naipe='ouros'))\n",
      "(2, Carta(valor='2', naipe='paus'))\n",
      "(3, Carta(valor='2', naipe='espadas'))\n",
      "(4, Carta(valor='3', naipe='copas'))\n",
      "(5, Carta(valor='3', naipe='ouros'))\n",
      "(6, Carta(valor='3', naipe='paus'))\n",
      "(7, Carta(valor='3', naipe='espadas'))\n",
      "(8, Carta(valor='4', naipe='copas'))\n",
      "(9, Carta(valor='4', naipe='ouros'))\n",
      "(10, Carta(valor='4', naipe='paus'))\n",
      "(11, Carta(valor='4', naipe='espadas'))\n",
      "(12, Carta(valor='5', naipe='copas'))\n",
      "(13, Carta(valor='5', naipe='ouros'))\n",
      "(14, Carta(valor='5', naipe='paus'))\n",
      "(15, Carta(valor='5', naipe='espadas'))\n",
      "(16, Carta(valor='6', naipe='copas'))\n",
      "(17, Carta(valor='6', naipe='ouros'))\n",
      "(18, Carta(valor='6', naipe='paus'))\n",
      "(19, Carta(valor='6', naipe='espadas'))\n",
      "(20, Carta(valor='7', naipe='copas'))\n",
      "(21, Carta(valor='7', naipe='ouros'))\n",
      "(22, Carta(valor='7', naipe='paus'))\n",
      "(23, Carta(valor='7', naipe='espadas'))\n",
      "(24, Carta(valor='8', naipe='copas'))\n",
      "(25, Carta(valor='8', naipe='ouros'))\n",
      "(26, Carta(valor='8', naipe='paus'))\n",
      "(27, Carta(valor='8', naipe='espadas'))\n",
      "(28, Carta(valor='9', naipe='copas'))\n",
      "(29, Carta(valor='9', naipe='ouros'))\n",
      "(30, Carta(valor='9', naipe='paus'))\n",
      "(31, Carta(valor='9', naipe='espadas'))\n",
      "(32, Carta(valor='10', naipe='copas'))\n",
      "(33, Carta(valor='10', naipe='ouros'))\n",
      "(34, Carta(valor='10', naipe='paus'))\n",
      "(35, Carta(valor='10', naipe='espadas'))\n",
      "(36, Carta(valor='A', naipe='copas'))\n",
      "(37, Carta(valor='A', naipe='ouros'))\n",
      "(38, Carta(valor='A', naipe='paus'))\n",
      "(39, Carta(valor='A', naipe='espadas'))\n",
      "(40, Carta(valor='J', naipe='copas'))\n",
      "(41, Carta(valor='J', naipe='ouros'))\n",
      "(42, Carta(valor='J', naipe='paus'))\n",
      "(43, Carta(valor='J', naipe='espadas'))\n",
      "(44, Carta(valor='Q', naipe='copas'))\n",
      "(45, Carta(valor='Q', naipe='ouros'))\n",
      "(46, Carta(valor='Q', naipe='paus'))\n",
      "(47, Carta(valor='Q', naipe='espadas'))\n",
      "(48, Carta(valor='K', naipe='copas'))\n",
      "(49, Carta(valor='K', naipe='ouros'))\n",
      "(50, Carta(valor='K', naipe='paus'))\n",
      "(51, Carta(valor='K', naipe='espadas'))\n"
     ]
    }
   ],
   "source": [
    "for carta in enumerate(baralho):\n",
    "    print(carta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorteio de cartas usando o módulo `random`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Carta(valor='9', naipe='ouros')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import choice\n",
    "\n",
    "choice(baralho)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Carta(valor='7', naipe='copas')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "choice(baralho)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Carta(valor='K', naipe='paus')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "choice(baralho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorteando 5 cartas (pode haver repetição):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Carta(valor='6', naipe='espadas'),\n",
       " Carta(valor='3', naipe='ouros'),\n",
       " Carta(valor='10', naipe='espadas'),\n",
       " Carta(valor='4', naipe='espadas'),\n",
       " Carta(valor='K', naipe='espadas')]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mao = [choice(baralho) for _ in range(5)]\n",
    "mao"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos verificar se uma carta específica está no baralho:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from exemplos.baralho import Carta\n",
    "\n",
    "Carta('10', 'espadas') in baralho"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Carta('3', 'alabardas') in baralho"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E se saber quantas cartas há no baralho:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(baralho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você deve estar se perguntando quanto custou para implementar tudo isso? Respota: muito pouco.\n",
    "\n",
    "```py\n",
    "\"\"\" Arquivo: 02-python-oo/aula-03/exemplos/baralho.py \"\"\"\n",
    "\n",
    "from collections import namedtuple\n",
    "\n",
    "\n",
    "Carta = namedtuple('Carta', ['valor', 'naipe'])\n",
    "\n",
    "\n",
    "class Baralho:\n",
    "    valores = [str(n) for n in range(2, 11)] + list('AJQK')\n",
    "    naipes = 'copas ouros paus espadas'.split()\n",
    "\n",
    "    def __init__(self):\n",
    "        self.cartas = [Carta(v, n) for v in self.valores for n in self.naipes]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.cartas)\n",
    "\n",
    "    def __getitem__(self, pos):\n",
    "        return self.cartas[pos]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Métodos especiais\n",
    "\n",
    "Vimos duas vantagens de usar os métodos especiais para tirar proveito do modelo de dados do Python:\n",
    "\n",
    "- Os usuarios de suas classes não precisarão memorizar nomes arbitrários de métodos para realizar operações comuns (Como \n",
    "obter a quantidade de itens? Uso `.size()`, `.length()`, ou o quê?)\n",
    "\n",
    "- Podemos se beneficiar da biblioteca-padrão do Python e não reinventar a roda, como visto no uso das funções `random.choice` e `reversed`.\n",
    "\n",
    "Os métodos especiais foram criados para serem chamados pelo interpretador Python e não diretamente. Não usamos `objeto.__len__`, para obter a quantidade de elementos, mas sim `len(objeto)`. Se `objeto` for a instância de uma classe definida pelo usuário (programador), o Python chamará o método `__len__` da instância.\n",
    "\n",
    "Na grande maioria das vezes a chamada aos métodos especiais será feita de forma implícita. Por exemplo, a construção de `for i in x` invoca `iter(x)`, que poderá chamar `x.__iter__()` se existir.\n",
    "\n",
    "Um exemplo comum de implementação e chamada de métodos especiais diretamente é o `__init__` para sobrescrever o inicilizador da superclasse. Também é comum invocar o inicializador da superclasse diretamente com, por exemplo, `super().__init__()` ao implementar seu próprio inicializador.\n",
    "\n",
    "Caso precise chamar um método especial, em geral é muito melhor chamar a função embutida relacionada ou a sintaxe especial (`obj[chave]`, `len`, `iter`, `str` etc.). Essas funções embutidas invocam o método especiail correspondente, porém, com frequência, oferecem outros serviços e - para os tipos embutidos - são mais rápidas que chamadas de métodos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `#`TODO\n",
    "\n",
    "Monkey patching em `__setitem__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Protocolo de Sequência\n",
    "\n",
    "Nós podemos fazer todas essas operações no `Baralho` sem herdar de alguma classe espeicial, pois implementamos o protocolo de sequência como definido no modelo de dados do Python. Agora ficam duas dúvidas: o que é exatamente um protocolo e uma sequência?\n",
    "\n",
    "No contexto de programação orientada a objetos um protocolo é uma interface informal definida somente na documentação e não no código. Por exemplo, o protocolo de sequência em Python implica somente os métodos `__len__` e `__getitem__`. Qualquer classe que implemente esses métodos poderá ser usada em qualquer lugar em que se espera uma sequência. \n",
    "\n",
    "Esse tipo de programação ficou conhecida como **Duck Typing** e é muito comum em linguagens dinâmicas como Python e Ruby.\n",
    "\n",
    "![Duck Typing](img/ducktyping.jpg)\n",
    "<center>A duck typing (pode ser traduzido como: tipagem pato ou pato digitando)</center>\n",
    "\n",
    "\"Não verifique se é um pato: verifique se faz *quack* como um pato, *anda* como um pato etc., de acordo com o subconjunto exatao de comportamento de pato de que você precisa para usar a linguagem.\" (Alex Martelli, 2000)\n",
    "\n",
    "Essa técnica consiste em não verificar se uma classe **é**, por exemplo, uma sequência e sim se ela se **comporta** como uma sequência.\n",
    "\n",
    "É importante notar que, como os protocolos são informais e não impostos. Geralmente você pode implementar somente a parte de um protocolo que faz sentido a sua aplicação sem que haja problemas. Por exemplo, para dar suporte a iteração é necessário implementar somente o método `__getitem__` e não é necessário o `__len__`\n",
    "\n",
    "Agora que sabemos como funcionam os protocolos em Python, vamos falar sobre o protocolo de sequência.\n",
    "\n",
    "O python data model define sequências como conjuntos finitos indexados por números não negativos. Sendo `n` o tamanho da sequência, os índices vão de 0 a `n` - 1 e são acessados por `a[i]`.\n",
    "\n",
    "Falaremos mais sobre o protocolo de sequência futuramente. Caso queira entender mais sobre o assunto consulte sua [documentação](https://docs.python.org/3/reference/datamodel.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Emulando tipos numéricos\n",
    "\n",
    "Vamos ver como utilizar os métodos especiais para emular tipos numéricos.\n",
    "\n",
    "O python data model diz que números são criados por números declará-los em sua forma literal (como por exemplo `a = 3`, `3.4` etc.) e resultados de operações aritméticos e funções aritméticas embutidas.\n",
    "\n",
    "Implementaremos uma classe para representar vetores bidimensionais (vetores euclidianos) usados na matemática e na física.\n",
    "\n",
    "<img src=\"img/vetor.jpg\" width=\"500\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from exemplos.vetor1 import Vetor\n",
    "\n",
    "v1 = Vetor(1, -2)\n",
    "v2 = Vetor(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos somar vetores usando o operador `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vetor(4, 2)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usar o operador de subtração:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vetor(-2, -6)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 - v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplicação por escalar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vetor(3, -6)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vetor(-12, -16)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 * -4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valor absoluto (distância do vetor até a origem):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparação de vetores por valor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 == v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 == Vetor(1, -2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 == Vetor(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos fazer verificações booleanas com o vetor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v1 existe e possui valor\n"
     ]
    }
   ],
   "source": [
    "if v1:\n",
    "    print('v1 existe e possui valor')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vetor não possui valor\n"
     ]
    }
   ],
   "source": [
    "if not Vetor(0, 0):\n",
    "    print('vetor não possui valor')\n",
    "else:\n",
    "    print('alguma coisa deu errado')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse exemplo usou a classe `Vetor` demonstrada a seguir, que implementa as operações demonstradas por meio dos métodos especiais `__repr__`, `__abs__`, `__add__`, `__bool__`, `__eq__`, `__sub__` e `__mul__`:\n",
    "\n",
    "```py\n",
    "\"\"\"\n",
    "Arquivo: 02-python-oo/aula-03/exemplos/vetor.py\n",
    "\n",
    "Implementa um vetor bidimensional\n",
    "\"\"\"\n",
    "import math\n",
    "\n",
    "\n",
    "class Vetor:\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Vetor({!r}, {!r})'.format(self.x, self.y)\n",
    "\n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "\n",
    "    def __add__(self, v2):\n",
    "        return Vetor(self.x + v2.x, self.y + v2.y)\n",
    "\n",
    "    def __bool__(self):\n",
    "        return bool(self.x or self.y)\n",
    "\n",
    "    def __eq__(self, v2):\n",
    "        return self.x == v2.x and self.y == v2.y\n",
    "\n",
    "    def __sub__(self, v2):\n",
    "        return Vetor(self.x - v2.x, self.y - v2.y)\n",
    "\n",
    "    def __mul__(self, scalar):\n",
    "        return Vetor(self.x * scalar, self.y * scalar)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método `__repr__` é responsável por retornar a representação do objeto para inspeção. Esse valor é usado no modo interativo e em debugers. Caso esse método não seja sobrescrito será exibido algo como `<Vetor object at 0x123e9230>`.\n",
    "\n",
    "A representação do objeto é obtido a partir da função embutida `repr()`. É uma boa prática usar `!r` para obter a representação dos atributos do objeto, pois mostra a diferença fundamental entre `Vector(1, 2)` e `Vector('1', '2')` - a última não funcionará, pois os argumentos do construtor devem ser número e não `str`.\n",
    "\n",
    "Também há o método `__str__` que é utilizado para exibir o valor do objeto para o usuário final. Para entender melhor a diferença consulte [esta thread do stack overflow](http://stackoverflow.com/questions/1436703/difference-between-str-and-repr-in-python) que foi muito bem respondida pelos pythonistas Alex Martelli e Martijn Peters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse exemplo contém alguns problemas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vetor(1, -2)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vetor(5, -10)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for *: 'int' and 'Vetor'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-30-e463c89cb0af>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m5\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mv1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'int' and 'Vetor'"
     ]
    }
   ],
   "source": [
    "5 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No exemplo anterior tentamos multiplicar um `int` por um `Vetor`, porém foi levantada uma exceção já que o tipo `int` não sabe multiplicar por `Vetor`. Apenas `Vetor` sabe multiplicar por escalar.\n",
    "\n",
    "Para resolver esse problema precisamos antes entender como funciona `x * y`:\n",
    "1. Se `x` tiver `x.__mul__`, chama `x.__mul__(y)` e devolve o resultado a menos que seja `NotImplemented`\n",
    "2. Se `x` não tiver `x.__mul__`, ou sua chamada devolver `NotImplemented`, verifica se `y` possui `__rmul__`, chama `y.__rmul__(x)` e devolve o resultado, a menos que seja `NotImplemented`\n",
    "3. Se `y` não tiver `__rmul__`, ou sua chamada devolver `NotImplented`, levanta `TypeError` com uma mensagem *unsupported operand type(s)*\n",
    "\n",
    "O método `__rmul__` é chamado de versão refletida, reversa ou direita (do inglês right) de `__mul__`.\n",
    "\n",
    "Para corrigir precisamos adicionar o método `__rmul__` à clase Vetor:\n",
    "\n",
    "```py\n",
    "import math\n",
    "\n",
    "class Vetor:\n",
    "    ...\n",
    "    \n",
    "    def __mul__(self, escalar):\n",
    "        return Vetor(self.x * escalar, self.y * escalar)\n",
    "    \n",
    "    def __rmul__(self, outro):\n",
    "        return self * outro\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém, ao adicionar esse código acontece outro problema:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for *: 'Vetor' and 'Vetor'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-33-3a0d23b5f017>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mexemplos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvetor2\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mVetor\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mVetor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mVetor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'Vetor' and 'Vetor'"
     ]
    }
   ],
   "source": [
    "from exemplos.vetor2 import Vetor\n",
    "\n",
    "Vetor(1, 2) * Vetor(2, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse resultado não faz sentido, não é assim que multiplicação de vetores funciona.\n",
    "\n",
    "Não vamos implementar aqui a multiplicação de vetores, pois o foco da aula é ensinar programação e não matemática. Portanto, precisamos permitir a multiplicação de vetores *apenas* por escalares, vamos corrigir a função `__mul__`:\n",
    "\n",
    "```py\n",
    "import math\n",
    "from numbers import Number\n",
    "\n",
    "class Vetor:\n",
    "    ...\n",
    "    \n",
    "    def __mul__(self, escalar):\n",
    "        if isinstance(escalar, Real):\n",
    "            return Vetor(self.x * escalar, self.y * escalar)\n",
    "        else:\n",
    "            return NotImplemented\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificamos se o escalar recebido de fato é um número real, se for retornamos o resultado da multiplicação do vetor pelo escalar, caso contrário é retornado `NotImplemented`. \n",
    "\n",
    "Retornamos `NotImplemented` ao invés de levantar uma exceção, para permitir que o Python tente executar `__rmul__` no `escalar`, pois pode ser que seja algum tipo que implemente a operação reversa da multiplicação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também há um problema com a comparação de valores quando comparamos vetores com outros tipos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute 'x'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-34-77c91994217a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mexemplos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvetor1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mVetor\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mVetor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m/home/luiz/talks/trilha/02-python-oo/aula-03/exemplos/vetor1.py\u001b[0m in \u001b[0;36m__eq__\u001b[1;34m(self, outro)\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__eq__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 25\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     26\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     27\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__sub__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'x'"
     ]
    }
   ],
   "source": [
    "from exemplos.vetor1 import Vetor\n",
    "\n",
    "Vetor(1, 3) == [1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'str' object has no attribute 'x'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-35-41a211be8d0e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mVetor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'oi'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m/home/luiz/talks/trilha/02-python-oo/aula-03/exemplos/vetor1.py\u001b[0m in \u001b[0;36m__eq__\u001b[1;34m(self, outro)\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__eq__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 25\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     26\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     27\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__sub__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moutro\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'str' object has no attribute 'x'"
     ]
    }
   ],
   "source": [
    "Vetor(2, 4) == 'oi'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essa comparação deveria retornar `False`, não levantar uma exceção. Podemos corrigir esse problema da seguinte maneira:\n",
    "\n",
    "```py\n",
    "import math\n",
    "from numbers import Number\n",
    "\n",
    "class Vetor:\n",
    "    ...\n",
    "\n",
    "    def __eq__(self, outro):                              \n",
    "        if isinstance(outro, Vetor):                      \n",
    "            return self.x == outro.x and self.y == outro.y\n",
    "        else:                                             \n",
    "            return NotImplemented                         \n",
    "\n",
    "```\n",
    "\n",
    "Agora podemos comparar `Vetor` com outros tipos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from exemplos.vetor2 import Vetor\n",
    "\n",
    "Vetor(1, 3) == 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vetor(-2, 3) == [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nosso vetor ainda não suporta operações unárias como `-v` e `+v`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "bad operand type for unary -: 'Vetor'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-b247c8b4fd1e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mexemplos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvetor1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mVetor\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[1;33m-\u001b[0m\u001b[0mVetor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: bad operand type for unary -: 'Vetor'"
     ]
    }
   ],
   "source": [
    "from exemplos.vetor1 import Vetor\n",
    "\n",
    "-Vetor(1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "bad operand type for unary +: 'Vetor'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-7d566f2c6e0b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m+\u001b[0m\u001b[0mVetor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: bad operand type for unary +: 'Vetor'"
     ]
    }
   ],
   "source": [
    "+Vetor(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que esses operadores funcionem precisamos definir os métodos `__neg__` e `__pos__`:\n",
    "\n",
    "```py\n",
    "from numbers import Real\n",
    "import math\n",
    "\n",
    "\n",
    "class Vetor:\n",
    "    ...\n",
    "    \n",
    "    def __neg__(self):\n",
    "        return self * -1\n",
    "\n",
    "    def __pos__(self):\n",
    "        return self\n",
    "```\n",
    "\n",
    "A função `__neg__` simplesmente retornou o vetor por `-1`. Já a função `__pos__` retorna a própria instância, pois `+Vetor(x, y)` é sempre igual a ele mesmo `Vetor(x, y)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seria interessante se pudessemos desempacotar os valores de `x` e de `y` de um vetor para uma tupla. Isso facilitaria nossa vida, pois poderiamos fazer isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v = Vetor(3, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Vetor' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-c2ef2c058e4f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'Vetor' object is not iterable"
     ]
    }
   ],
   "source": [
    "x, y = v\n",
    "x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ao invés disso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, -1)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = v.x\n",
    "y = v.y\n",
    "x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O desempacotamento facilita ainda mais nossa vida se tivessemos uma lista de vetores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Vetor(7, -8), Vetor(0, -5), Vetor(-6, 0), Vetor(0, 2), Vetor(6, -8)]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "lista_vetores = [Vetor(x=randint(-10, 10), y=randint(-10, 10)) for _ in range(5)]\n",
    "lista_vetores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pois poderiamos ter acesso facilitado a `x` e `y` durante uma iteração usando o desempacotamento de sequências:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Vetor' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-21-680936c471bd>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mlista_vetores\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'Vetor' object is not iterable"
     ]
    }
   ],
   "source": [
    "for x, y in lista_vetores:\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ao invés de ter que acessar os atributos diretamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 -8\n",
      "0 -5\n",
      "-6 0\n",
      "0 2\n",
      "6 -8\n"
     ]
    }
   ],
   "source": [
    "for vetor in lista_vetores:\n",
    "    print(vetor.x, vetor.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de implementar essa funcionalidade precisamos entender como funciona o desempacotamento de sequências: o objeto a direita é iterado e cada variável a esquerda é atribuída ao item resultante dessa iteração."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a, b) = (1, 0)\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[a, b] = [3, 4]\n",
    "a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que acontece por trás de tudo isso é: Extraímos o iterador da sequência a direita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "iterador = iter([3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ele é iterado uma vez e o resultado da iteração é atribuído a primeira variável:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = next(iterador)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E é iterado até chegar ao último elemento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = next(iterador)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que sabemos disso fica claro que, para nosso vetor ser desempacotado precisamos torná-lo iterável. Para isso podemos definir o método `__iter__` que deve retornar um iterador:\n",
    "\n",
    "```py\n",
    "\n",
    "...\n",
    "\n",
    "class Vetor:\n",
    "    ...\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return iter((self.x, self.y))\n",
    "```\n",
    "\n",
    "Nesse método definimos uma tupla composta pelos atributos `x` e `y` da instância do `Vetor` e retornamos o iterador da dessa tupla."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essa implementação funciona, porém podemos usar geradores para deixar esse método mais simples e eficiente:\n",
    "\n",
    "```py\n",
    "\n",
    "...\n",
    "\n",
    "class Vetor:\n",
    "    ...\n",
    "    \n",
    "    def __iter__(self):\n",
    "        yield self.x; yield self.y\n",
    "```\n",
    "\n",
    "Para entender essa implementação é necessário conhecer o funcionamento de geradores, que veremos numa aula futura."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As operações que implementamos para nosso vetor não o alteram, mesmo quando usamos operadores acumulados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Vetor(1, 2), 140691520740152)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from exemplos.vetor2 import Vetor\n",
    "\n",
    "v = Vetor(1, 2)\n",
    "v, id(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se realizarmos uma soma acumulada com outro vetor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Vetor(3, 5), 140691520740320)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v += Vetor(2, 3)\n",
    "v, id(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um novo objeto é criado, pois o objeto referenciado pela variável `v` não é mais o mesmo (a identidade dos objetos são diferentes).\n",
    "\n",
    "Para que essas operações de fato modifiquem um objeto, como acontecem com objetos mutáveis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4], 140691520641416)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "lista, id(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, 5, 6, 7, 8], 140691520641416)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista += [5, 6, 7, 8]\n",
    "lista, id(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O objeto permanece o mesmo, seu valor que é alterado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matemáticamente não faz muito sentido ter um vetor mutável, mas para entendermos melhor esses conceitos vamos fazer um `VetorMutável`, como subclasse de `Vetor`, que altere o valor do vetor quanto as operações `+=` e `*=` forem usadas implementando os métodos `__iadd__` e `__imul__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(VetorMutavel(2, 3), 140691520738752)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from exemplos.vetor2 import VetorMutavel\n",
    "\n",
    "vm = VetorMutavel(2, 3)\n",
    "vm, id(vm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(VetorMutavel(1, 7), 140691520738752)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vm += VetorMutavel(-1, 4)\n",
    "vm, id(vm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(VetorMutavel(-2, -14), 140691520738752)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vm *= -2\n",
    "vm, id(vm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essa classe `VetorMutavel` pode ser implementada da seguinte maneira:\n",
    "\n",
    "```py\n",
    "\n",
    "class VetorMutavel(Vetor):\n",
    "\n",
    "    def __iadd__(self, outro):\n",
    "        if isinstance(outro, Vetor):\n",
    "            self.x += outro.x \n",
    "            self.y += outro.y\n",
    "            return self\n",
    "        return NotImplemented\n",
    "            \n",
    "    def __imul__(self, outro):\n",
    "        if isinstance(outro, Real):\n",
    "            self.x *= outro\n",
    "            self.y *= outro\n",
    "            return self\n",
    "        return NotImplemented\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Emulando tipos chamáveis\n",
    "\n",
    "Chamáveis são os tipos que podem ser chamados ou invocados quando escrevemos seu nome seguido por parentesis e podem receber argumentos. São chamáveis:\n",
    "\n",
    "- Funções:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def chamavel():\n",
    "    print('posso ser chamado')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "posso ser chamado\n"
     ]
    }
   ],
   "source": [
    "chamavel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(chamavel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Foo:\n",
    "    def bar(self):\n",
    "        print('também posso ser chamado!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando classes são chamadas retornam instâncias:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "foo = Foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Métodos de instâncias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "também posso ser chamado!\n"
     ]
    }
   ],
   "source": [
    "foo.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Geradores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def gen():\n",
    "    yield 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chamar geradores retorna objetos geradores que executam o código definido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object gen at 0x7f0e343eeeb8>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acessar o conteúdo do gerador precisamos iterá-lo, para isso podemos usar a função embutida `next()` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = gen()\n",
    "next(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém se requisitamos mais valores de um gerador que ele pode gerar uma exceção é levantada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-5f315c5de15b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veremos mais sobre geradores nas próximas aulas. Para saber mais sobre chamáveis consulte o [python data model](https://docs.python.org/3/reference/datamodel.html) e [como chamáveis são expressados](https://docs.python.org/3/reference/expressions.html#calls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Objetos\n",
    "\n",
    "Por fim, objetos que definem um método `__call__` também são chamáveis.\n",
    "\n",
    "Para demonstrar isso vamos implementar uma tombola (gaiola de bingo). A tombola pode:\n",
    "- Carregar itens\n",
    "- Inspecionar itens da tombola\n",
    "- Verificar se está vazia\n",
    "- Misturar itens\n",
    "- Sortear um item\n",
    "- Sortear um item chamando a instância da tombola\n",
    "\n",
    "Vamos ao código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "class Tombola:\n",
    "    def __init__(self, itens=None):\n",
    "        self._itens = []\n",
    "        self.carrega(itens)\n",
    "        \n",
    "    def __call__(self):\n",
    "        return self.sorteia()\n",
    "\n",
    "    def carrega(self, itens):\n",
    "        self._itens.extend(itens)\n",
    "\n",
    "    def inspeciona(self):\n",
    "        return tuple(self._itens)\n",
    "\n",
    "    def mistura(self):\n",
    "        random.shuffle(self._itens)\n",
    "\n",
    "    def sorteia(self):\n",
    "        return self._itens.pop()\n",
    "\n",
    "    def vazia(self):\n",
    "        return len(self._itens) == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos criar nossa tombola que armazena os números de 1 a 20:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tombola = Tombola(range(1, 21))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificaremos seus itens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola.inspeciona()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Está vazia?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola.vazia()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Misturando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 2, 1, 13, 12, 6, 15, 20, 18, 5, 3, 17, 10, 14, 16, 9, 11, 4, 19, 7)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola.mistura()\n",
    "tombola.inspeciona()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorteando um item da maneira clássica:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola.sorteia()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aproveitando o método `__call__` que definimos podemos sortear chamado o objeto `tombola` sem chamar o método `tombola.sorteia()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os operadores \"aritméticos\" (como `+`, `*` etc.) também podem ser aplicados a outros objetos para realizar operações que fazem sentido a esse objetos. Como por exemplo em listas e strings, em que o operador `+` realiza a concatenação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista + [5, 6, 7, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-4, -3, -2, -1, 0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[-4, -3, -2, -1, 0] + lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'palavra'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pal = \"palavra\"\n",
    "pal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'palavra!!!1!1!11onze!!!1!'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pal + '!!!1!1!11onze!!!1!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para mostrar como isso funciona vamos implementar uma tombola expansível que torne possível juntar os itens dessa tombola com outra tombola ou um iterável.\n",
    "\n",
    "Vamos definir o método `__add__` para permitir a \"soma\" de tombolas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class TombolaExpansivel(Tombola):\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, Tombola):\n",
    "            return TombolaExpansivel(self.inspeciona() + other.inspeciona())\n",
    "        else:\n",
    "            return NotImplemented"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na linha 3 verificamos se o objeto somado é uma instância de `Tombola`, isso permite que nossa `TombolaExpansivel` seja somada com `Tombola` e todas suas subclasses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola_exp = TombolaExpansivel(range(1, 11))\n",
    "tombola_exp.inspeciona()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos somar a instância de `TombolaExpansivel` com `Tombola` e suas subclasses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "outra_tombola = tombola_exp + Tombola(range(11, 21))\n",
    "outra_tombola.inspeciona()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mais_tombolas = tombola_exp + TombolaExpansivel(range(11, 16))\n",
    "mais_tombolas.inspeciona()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sobrescrevendo o método `__add__` já é possível usar a soma atribuída, porém haverá um problema indesejado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(139698982480304, (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(tombola_exp), tombola_exp.inspeciona()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(139698982479800, (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola_exp += Tombola(range(11, 16))\n",
    "id(tombola_exp), tombola_exp.inspeciona()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos que as identidades dos objetos atribuidos a tombola_exp são diferentes. Isso por que a atribuição acumulada, por padrão, na verdade faz: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tombola_exp = tombola_exp + Tombola(range(16, 21))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola_exp.inspeciona()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E nossa função o `__add__` cria um novo objeto. Como queremos que nossa `TombolaExpansivel` seja mutável, precisamos definir o método `__iadd__` para modificar a instância.\n",
    "\n",
    "Aproveitando que vamos mexer no `__iadd__` podemos melhorar nossa tombola para receber item de qualquer iterável e não somente de `Tombola` e suas subclasses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class TombolaExpansivel(Tombola):\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, Tombola):\n",
    "            return TombolaExpansivel(self.inspeciona() + other.inspeciona())\n",
    "        else:\n",
    "            return NotImplemented\n",
    "    \n",
    "    def __iadd__(self, outro):\n",
    "        if isinstance(outro, Tombola):\n",
    "            outro_iteravel = outro.inspeciona()\n",
    "        else:\n",
    "            try:\n",
    "                outro_iteravel = iter(outro)\n",
    "            except TypeError:\n",
    "                msg = \"operando da direita no += deve ser {!r} ou um iterável\"\n",
    "                raise TypeError(msg.format(type(self).__name__))\n",
    "        self.carrega(outro_iteravel)\n",
    "        return self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Linha 9 e 10: se o objeto à direita for uma tombola inspecionamos e \"pegamos\" seus itens\n",
    "\n",
    "Linha 12 e 13: tenta extrair um iterável do objeto a direita, isso funcionará se este objeto for iterável, se não uma exceção do tipo `TypeError` é levantada.\n",
    "\n",
    "Linha 14, 15 e 16: Se for levantada uma exceção `TypeError` é criada uma outra exceção do tipo `TypeError`, porém com uma mensagem de erro mais clara.\n",
    "\n",
    "Linha 17: carrega os próprios itens e da outra tupla.\n",
    "\n",
    "Agora podemos, de fato, modificar nossa `TombolaExpansível`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(139698982617496, (-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0))"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola_exp = TombolaExpansivel(range(-10, 1, 1))\n",
    "id(tombola_exp), tombola_exp.inspeciona()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(139698982617496, (-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tombola_exp += [1, 2, 3, 4]\n",
    "id(tombola_exp), tombola_exp.inspeciona()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para finalizar, vamos ver uma tabela todos os métodos especiais do Python. Algum dos métodos especiais ainda não foram explicados no curso e outros não serão, portanto consulte a [documentação](https://docs.python.org/3/reference/datamodel.html) caso você precise deles. \n",
    "\n",
    "#### Tabela de métodos mágicos\n",
    "\n",
    "*Esta tabela foi tirada do livro Fluent Python (Python Fluente)*\n",
    "\n",
    "Na tabela a seguir constam todos os métodos mágicos por tipo. (em inglês, pois não há ebook da versão pt-br)\n",
    "\n",
    "![](img/special1.png)\n",
    "![](img/special2.png)\n",
    "![](img/special3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Fim da aula 03**"
   ]
  }
 ],
 "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.1+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}