10 - Orientação à Objetos - O estilo Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes e Objetos\n",
    "\n",
    "Em Python, é possível implementar o conceito de orientação à objetos de forma leve. Vamos começar com um exemplo simples de classe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, felipe\n"
     ]
    }
   ],
   "source": [
    "class Pessoa():\n",
    "    def __init__(self, nome):\n",
    "        self.nome = nome\n",
    "        \n",
    "    def cumprimentar(self):\n",
    "        print(\"Olá, {}\".format(self.nome))\n",
    "        \n",
    "felipe = Pessoa('felipe')\n",
    "felipe.cumprimentar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante notar alguns pontos dessa sintaxe.\n",
    "\n",
    "`class Pessoa()`\n",
    "\n",
    "A primeira linha define que implementaremos uma classe, damos o seu nome e, entre parênteses, podemos definir as classes que serão herdadas. Como não herdamos nenhuma, esses parênteses poderiam ser omitidos.\n",
    "\n",
    "`def __init__(self, nome)`\n",
    "\n",
    "`__init__` — com dois _underlines_ antes e depois do nome — é a sintaxe que usamos para definir um construtor em Python. O primeiro argumento de qualquer método de instância é o `self`. Esse argumento vai conter uma referência à instância em questão.\n",
    "\n",
    "`self.nome` faz com que o atributo \"nome\" da instância seja configurado. No corpo do construtor podemos fazer todo tipo de inicializações que uma instância pode precisar.\n",
    "\n",
    "`def cumprimentar(self)` define um método de instância. O argumento `self` é necessário em todos os métodos desse tipo e ele também será preenchido automaticamente pelo interpretador com uma referência ao objeto atual.\n",
    "\n",
    "`felipe = Pessoa('felipe')` cria uma nova instância da classe `Pessoa`, passando o atributo `felipe` como nome e a armazena na variável `felipe`.\n",
    "\n",
    "`felipe.cumprimentar()` executa um método de instância"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herança\n",
    "\n",
    "Python permite que heranças sejam feitas direto na definição da classe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Usuário(Pessoa):\n",
    "    \n",
    "    def __init__(self, nome, email):\n",
    "        self.nome = nome\n",
    "        self.email = email\n",
    "        \n",
    "    def mandar_email(self):\n",
    "        print(\"Mandando email para {} no email {}\".format(self.nome, self.email))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Olá, felipe\n",
      "Mandando email para felipe no email felipe@felipevr.com\n"
     ]
    }
   ],
   "source": [
    "u = Usuário(\"felipe\", \"felipe@felipevr.com\")\n",
    "u.cumprimentar()\n",
    "u.mandar_email()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que na linha 2 utilizamos do método `cumprimentar` partindo de uma instância de Usuário. No entanto, esse método não está definido no Usuário em si mas sim na Pessoa, classe mãe da classe Usuário"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Métodos de Classe\n",
    "\n",
    "As vezes precisamos declarar métodos que não variam de acordo com uma instância em especial mas que são compartilhados por todas elas de maneira igual. Em Python isso é feito usando métodos estáticos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Aritmética:\n",
    "    @staticmethod\n",
    "    def soma(a, b):\n",
    "        return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aritmética.soma(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que não precisamos instanciar um objeto da classe e que na definição do método não existe o argumento `self`. As duas coisas acontecem porque a definição de soma é ligada à classe e não depende das suas instância. Poderíamos instanciar, se quiséssemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = Aritmética()\n",
    "a.soma(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Atributos protegidos e privados\n",
    "\n",
    "Python não possui muito rigor no que diz respeito à atributos desse tipo. É possível criar atributos que são ocultos a primeira vista, mas, se o programador realmente quiser, ele consegue acessá-los:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cão():\n",
    "    def __método_privado(self):\n",
    "        print(\"Métodos 'privados' começam com 2 underlines!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Cão' object has no attribute '__método_privado'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-b3595482eaa9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mCão\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__método_privado\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Cão' object has no attribute '__método_privado'"
     ]
    }
   ],
   "source": [
    "c = Cão()\n",
    "c.__método_privado()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tivemos um erro! O atributo parece protegido, porém:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Métodos 'privados' começam com 2 underlines!\n"
     ]
    }
   ],
   "source": [
    "c._Cão__método_privado()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O ocultamento extremo de atributos — assim como muita coisa na linguagem — acontece por convenção e não por imposição. Ao marcá-los com dois underlines, você manda uma mensagem para outros colegas que possam utilizar sua classe: \"Eu não recomendo que você mexa aqui. No design da minha classe, eu não considerei as consequências para caso esse atributo seja acessado/modificado externamente\"\n",
    "\n",
    "Porém, se o outro programador realmente souber o que está fazendo e julgar necessária a manipulação daquele atributo, Python irá permitir. É bom lembrar que a definição de métodos como sendo privados não tem relação com segurança das informações armazenadas. Marcar atributos como sendo protegidos ou privados é simplesmente uma forma que temos de marcar o design da nossa classe e orientar outros programadores sobre como pensamos originalmente seu uso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Propriedades dinâmicas\n",
    "\n",
    "Uma coisa que é muito comum em orientação à objetos é a necessidade de realizar computações mais elaboradas ao ler e escrever campos de nossas classes. Em algumas linguagens isso é feito ocultando as variáveis que não queremos que sejam acessadas externamente e tornando públicos métodos para manipulá-las. Algo do tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContaCorrente():\n",
    "    def __init__(self, saldo, limite):\n",
    "        self.__saldo = saldo\n",
    "        self.__limite = limite\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "        \n",
    "    def get_saldo(self):\n",
    "        return self.__saldo + self.__limite\n",
    "    \n",
    "    def set_saldo(self, saldo):\n",
    "        self.__saldo = saldo\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "        \n",
    "    def get_cliente_vip(self):\n",
    "        return self.__cliente_vip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = ContaCorrente(10, 20)\n",
    "c.get_saldo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.set_saldo(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.get_saldo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.get_cliente_vip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudo funciona! Temos nossos atributos protegidos e temos funções que fazem calculos mais elaborados ao acessarmos e lermos variáveis. Porém, Python introduz uma sintaxe mais elegante para realizar esse tipo de operação, através da anotação `property`.\n",
    "\n",
    "Ao usarmos `property` podemos definir um método como sendo o resultado direto de uma chamada de leitura de uma propriedade, deixando o código mais limpo e amigável. Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContaCorrente():\n",
    "    def __init__(self, saldo, limite):\n",
    "        self.__saldo = saldo\n",
    "        self.__limite = limite\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "        \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self.__saldo + self.__limite\n",
    "    \n",
    "    def set_saldo(self, saldo):\n",
    "        self.__saldo = saldo\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "    \n",
    "    @property   \n",
    "    def cliente_vip(self):\n",
    "        return self.__cliente_vip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = ContaCorrente(20, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1.saldo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos mexer mais no código e criar um \"setter\" mais elegante para o saldo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContaCorrente():\n",
    "    def __init__(self, saldo, limite):\n",
    "        self.__saldo = saldo\n",
    "        self.__limite = limite\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "        \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self.__saldo + self.__limite\n",
    "    \n",
    "    @saldo.setter\n",
    "    def saldo(self, saldo):\n",
    "        self.__saldo = saldo\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "    \n",
    "    @property   \n",
    "    def cliente_vip(self):\n",
    "        return self.__cliente_vip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "c2 = ContaCorrente(10, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2.saldo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "c2.saldo = 100000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100100"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2.saldo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2.cliente_vip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pronto! Utilizando dessa sintaxe nós conseguimos executar lógicas arbitrariamente elaboradas ao ler e escrever atributos de nossos objetos. Quando o usuário de uma classe quer ler um valor, não interessa para ele se uma função foi executada para o cálculo. A única coisa que interessa é o valor em si. A sintaxe de `property` e `setter` permite que a gente faça todo tipo de computação que quisermos ao manipular valores dos objetos mas mantendo uma notação limpa e clara, ocultando as chamadas de função quando tudo o que de fato queremos são valores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sobrecarga de Operadores\n",
    "\n",
    "Somar números inteiros é fácil e direto — `a + b` — e somar objetos que nós definimos? Como implementaríamos a soma de duas contas?\n",
    "\n",
    "Suponha que a operação \"somar conta\" seja definida da seguinte forma: a soma de duas contas é uma nova conta que contém a soma do saldo das duas e o limite da maior delas. Poderíamos implementar uma função que faz o trabalho mas Python permite que a gente define o que significa o operador `+` no contexto de nosso código! Isso é a sobrecarga de operadores.\n",
    "\n",
    "Na realidade, diversos operadores usados na linguagem são chamadas de função que acontecem internamente. A [documentação](https://docs.python.org/3.7/reference/datamodel.html#emulating-numeric-types) contém o nome dessas funções.  Também é possível sobrecarregar os [operadores de comparação](https://docs.python.org/3.7/reference/datamodel.html#object.__lt__)e muitos outros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContaCorrente():\n",
    "    def __init__(self, saldo, limite):\n",
    "        self.__saldo = saldo\n",
    "        self.__limite = limite\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "        \n",
    "    @property\n",
    "    def saldo_especial(self):\n",
    "        return self.__saldo + self.__limite\n",
    "    \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self.__saldo\n",
    "    \n",
    "    @saldo.setter\n",
    "    def saldo(self, saldo):\n",
    "        self.__saldo = saldo\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "    \n",
    "    @property   \n",
    "    def cliente_vip(self):\n",
    "        return self.__cliente_vip\n",
    "\n",
    "    @property\n",
    "    def limite(self):\n",
    "        return self.__limite\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if self.limite > other.limite:\n",
    "            limite = self.limite\n",
    "        else:\n",
    "            limite = other.limite\n",
    "            \n",
    "        return ContaCorrente(self.saldo + other.saldo, limite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "conta_a = ContaCorrente(10, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "conta_b = ContaCorrente(5, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "conta_c = conta_a + conta_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conta_c.saldo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conta_c.limite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudo funcionou! Porém, se tentarmos inspecionar objetos do tipo ContaCorrente direto do terminal, teremos problemas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.ContaCorrente at 0x7f571c1e0198>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conta_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.ContaCorrente object at 0x7f571c1e0198>\n"
     ]
    }
   ],
   "source": [
    "print(conta_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A informação não é nada clara... Para fazer isso acontecer, temos dois métodos para sobrepor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContaCorrente():\n",
    "    def __init__(self, saldo, limite):\n",
    "        self.__saldo = saldo\n",
    "        self.__limite = limite\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "        \n",
    "    @property\n",
    "    def saldo_especial(self):\n",
    "        return self.__saldo + self.__limite\n",
    "    \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self.__saldo\n",
    "    \n",
    "    @saldo.setter\n",
    "    def saldo(self, saldo):\n",
    "        self.__saldo = saldo\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "    \n",
    "    @property   \n",
    "    def cliente_vip(self):\n",
    "        return self.__cliente_vip\n",
    "\n",
    "    @property\n",
    "    def limite(self):\n",
    "        return self.__limite\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if self.limite > other.limite:\n",
    "            limite = self.limite\n",
    "        else:\n",
    "            limite = other.limite\n",
    "            \n",
    "        return ContaCorrente(self.saldo + other.saldo, limite)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"<ContaCorrente: saldo R${}, limite R${}>\".format(self.__saldo, self.__limite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = ContaCorrente(10, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.ContaCorrente at 0x7f571c1f7668>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<ContaCorrente: saldo 10, limite 30>\n"
     ]
    }
   ],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bom, agora conseguimos usar o print mas ainda não conseguimos inspecionar o que está acontecendo direto da linha de comando! Isso acontece porque definimos o método `__str__` que define apenas como vai ser a representação desse objeto como string. Python implementa um outro método, o `__repr__`.\n",
    "\n",
    "É comum programadores usarem o terminal para testar códigos de maneira interativa. O problema é que nem sempre o que precisamos na representação do objeto no terminal faz sentido ser colocado na representação de string desse objeto. Quando estamos programando, talvez a gente queira mais informações do que o que é colocado nessa representação. Para isso, implementamos `__repr__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContaCorrente():\n",
    "    def __init__(self, saldo, limite):\n",
    "        self.__saldo = saldo\n",
    "        self.__limite = limite\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "        \n",
    "    @property\n",
    "    def saldo_especial(self):\n",
    "        return self.__saldo + self.__limite\n",
    "    \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self.__saldo\n",
    "    \n",
    "    @saldo.setter\n",
    "    def saldo(self, saldo):\n",
    "        self.__saldo = saldo\n",
    "        self.__cliente_vip = saldo > 10000\n",
    "    \n",
    "    @property   \n",
    "    def cliente_vip(self):\n",
    "        return self.__cliente_vip\n",
    "\n",
    "    @property\n",
    "    def limite(self):\n",
    "        return self.__limite\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if self.limite > other.limite:\n",
    "            limite = self.limite\n",
    "        else:\n",
    "            limite = other.limite\n",
    "            \n",
    "        return ContaCorrente(self.saldo + other.saldo, limite)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"<ContaCorrente: saldo R${}, limite R${}>\".format(self.__saldo, self.__limite)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return \"<ContaCorrente em desenvolvimento! Saldo {}, limite{}, endereço {}>\".format(self.__saldo, self.__limite, id(self))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = ContaCorrente(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<ContaCorrente em desenvolvimento! Saldo 10, limite20, endereço 140012110721600>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}