06-Objetos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O Python é uma linguagem orientada a objetos. O [Wikipedia][wiki] define Programação orientada a objetos:\n",
    "\n",
    "> Programação orientada a objetos (POO, ou OOP segundo as suas siglas em inglês) é um paradigma de programação baseado no conceito de \"objetos\", que podem conter dados na forma de campos, também conhecidos como atributos, e códigos, na forma de procedimentos, também conhecidos como métodos. Uma característica de objetos é que um procedimento de objeto pode acessar, e geralmente modificar, os campos de dados do objeto com o qual eles estão associados (objetos possuem uma noção de \"this\" (este) ou \"self\" (próprio)).\n",
    "\n",
    "> Em POO, programas de computadores são projetados por meio da composição de objetos que interagem com outros. Há uma diversidade significante de linguagens de POO, mas as mais populares são aquelas baseadas em classes, significando que objetos são instâncias de classes, que, normalmente, também determinam seu tipo.\n",
    "\n",
    "Vamos começar de forma prática definindo um objeto da vida real: uma emprea. \n",
    "\n",
    "[wiki]: https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_orientada_a_objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Empresa():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir um objeto, usamos a palavra reservada `class` e, por convenção, escrevemos o nome do objeto usando o formato [CamelCase][CamelCase].\n",
    "\n",
    "E podemos instanciar (inicializar) o nosso objeto da seguinte forma:\n",
    "\n",
    "\n",
    "[CamelCase]: https://pt.wikipedia.org/wiki/CamelCase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "py_consultoria = Empresa()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Empresa"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(py_consultoria)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Empresa object at 0x7f5148099c90>\n"
     ]
    }
   ],
   "source": [
    "print(py_consultoria)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por enquanto, nosso objeto não possui nenhuma propriedade. Por isso, precisei usar a palavra reservada `pass` que permite que eu simplesmente passe adiante. Podemos verificar que não temos nenhuma propriedade acessando o dicionário de propriedades interno do objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definindo métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nossa empresa realiza ações no mundo real. Assim, definimos métodos que executam estas ações criando funções associadas a estes objetos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Empresa():\n",
    "    \n",
    "    def contrata_funcionario(self, setor):\n",
    "        print(f\"Funcionário do setor {setor} contratado.\")\n",
    "        \n",
    "    def demite_funcionario(self, setor):\n",
    "        print(f\"Funcionário do setor {setor} demitido.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definimos dois métodos para o nosso objeto `Empresa`: `contrata_funcionario` e `demite_funcionario`.  A sintaxe é a mesma usada para definir uma função, a única diferença é a palavra `self` como primeiro parâmetro que referencia a própria instância criada. O nome `self` é uma conveção e pode ser o que você quiser. Voltaremos a ele mais tarde.\n",
    "\n",
    "Vamos instanciar novamente nosso objeto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "py_consultoria = Empresa()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para executar algum método, usamos a notação com ponto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Funcionário do setor TI contratado.\n"
     ]
    }
   ],
   "source": [
    "py_consultoria.contrata_funcionario(setor='TI')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Funcionário do setor Marketing demitido.\n"
     ]
    }
   ],
   "source": [
    "py_consultoria.demite_funcionario(setor='Marketing')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nosso objeto já está começando a mapear melhor a entidade no mundo real."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definindo atributos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A nossa empresa do mundo real possui alguns atributos, como nome e número de funcionários. Então, precisamos mapeá-los no nosso objeto e, para isso, utilizamos o método especial `__init__` para isso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Empresa():\n",
    "    \n",
    "    def __init__(self, nome, n_funcionarios = 0):\n",
    "        self.nome = nome\n",
    "        self.n_funcionarios = n_funcionarios\n",
    "    \n",
    "    def contrata_funcionario(self, setor):\n",
    "        print(f\"Funcionário do setor {setor} contratado.\")\n",
    "        self.n_funcionarios += 1\n",
    "        \n",
    "    def demite_funcionario(self, setor):\n",
    "        if self.n_funcionarios == 0:\n",
    "            raise Exception('A empresa possui 0 funcionários. Assim, não é possível demitir ninguém.')\n",
    "        \n",
    "        print(f\"Funcionário do setor {setor} demitido.\")\n",
    "        self.n_funcionarios -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver método a método:\n",
    "\n",
    "1. `__init__`: este método especial inicializa os atributos dos objetos que são passados como argumentos das funções. No nosso objeto `Empresa`, o argumento `nome` é obrigatório enquanto o argumento `n_funcionarios` não ém e receberá o valor `0` por padrão.\n",
    "   \n",
    "   A palavra `self` aparece novamente aqui e desta vez também aparece no corpo do método além de aparecer como argumento. Como dito antes, ela é utilizada para referenciar o objeto instanciado. No corpo do método, usamos `self` para atribuir os argumentos passados.\n",
    "1. `contrata_funcionarios`: adicionamos uma linha em que adiciona mais um ao contador do número de funcionários cada vez que o método é chamado.\n",
    "1. `demite_funcionarios`: semelhante ao método anterior, subtraimos um do contador do número de funcionários. Mas antes, verificamos que o resultado da subtração não é negativo. Se for, não realizamos a subtração e retornamos um erro.\n",
    "\n",
    "Vamos verificar como funciona. Começaremos instanciando o objeto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "py_consultoria = Empresa(nome='Py Consultoria', n_funcionarios=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acessar estes atributos usando a notação com ponto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A empresa Py Consultoria possui 6 funcionários.\n"
     ]
    }
   ],
   "source": [
    "print(f'A empresa {py_consultoria.nome} possui {py_consultoria.n_funcionarios} funcionários.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos contratar um funcionário:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Funcionário do setor RH contratado.\n"
     ]
    }
   ],
   "source": [
    "py_consultoria.contrata_funcionario(setor='RH')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A empresa Py Consultoria possui 7 funcionários.\n"
     ]
    }
   ],
   "source": [
    "print(f'A empresa {py_consultoria.nome} possui {py_consultoria.n_funcionarios} funcionários.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Infelizmente, precisamos reduzir nosso quadro de funcionários:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Funcionário do setor TI demitido.\n"
     ]
    }
   ],
   "source": [
    "py_consultoria.demite_funcionario(setor='TI')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A empresa Py Consultoria possui 6 funcionários.\n"
     ]
    }
   ],
   "source": [
    "print(f'A empresa {py_consultoria.nome} possui {py_consultoria.n_funcionarios} funcionários.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos verificar como fucnionaria se demitissemos um funcionário de uma empresa sem funcionários:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "A empresa possui 0 funcionários. Assim, não é possível demitir ninguém.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-c82e3a82a385>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mempresa_fantasma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEmpresa\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnome\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Gaspar Palestras'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mempresa_fantasma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdemite_funcionario\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msetor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'financeiro'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-9-3b725d616043>\u001b[0m in \u001b[0;36mdemite_funcionario\u001b[0;34m(self, setor)\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mdemite_funcionario\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msetor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_funcionarios\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'A empresa possui 0 funcionários. Assim, não é possível demitir ninguém.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Funcionário do setor {setor} demitido.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mException\u001b[0m: A empresa possui 0 funcionários. Assim, não é possível demitir ninguém."
     ]
    }
   ],
   "source": [
    "empresa_fantasma = Empresa(nome='Gaspar Palestras')\n",
    "empresa_fantasma.demite_funcionario(setor='financeiro')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definindo métodos especiais "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos exemplos acima, utilizamos a mesma sentença para verificar os atributos do nosso objeto. Podemos embuti-lo na definição do objeto para que seja mostrado cada vez que usarmos o `print` no objeto criado. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Empresa():\n",
    "    \n",
    "    def __init__(self, nome, n_funcionarios = 0):\n",
    "        self.nome = nome\n",
    "        self.n_funcionarios = n_funcionarios\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f'A empresa {self.nome} possui {self.n_funcionarios} funcionários.'\n",
    "    \n",
    "    def contrata_funcionario(self, setor):\n",
    "        print(f\"Funcionário do setor {setor} contratado.\")\n",
    "        self.n_funcionarios += 1\n",
    "        \n",
    "    def demite_funcionario(self, setor):\n",
    "        if self.n_funcionarios == 0:\n",
    "            raise Exception('A empresa possui 0 funcionários. Assim, não é possível demitir ninguém.')\n",
    "        \n",
    "        print(f\"Funcionário do setor {setor} demitido.\")\n",
    "        self.n_funcionarios -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizamos o método especial `__str__` que vai ser chamado qaundo usarmos o `print`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A empresa Py Consultoria possui 6 funcionários.\n"
     ]
    }
   ],
   "source": [
    "py_consultoria = Empresa(nome='Py Consultoria', n_funcionarios=6)\n",
    "print(py_consultoria)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um outro método especial que podemos usar é o que representa a instância ao ser invocada diretamente, como mostrado abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Empresa at 0x7f51417cc510>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py_consultoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos melhorar a sua representação usando o método especial `__repr__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Empresa():\n",
    "    \n",
    "    def __init__(self, nome, n_funcionarios = 0):\n",
    "        self.nome = nome\n",
    "        self.n_funcionarios = n_funcionarios\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f'A empresa {self.nome} possui {self.n_funcionarios} funcionários.'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"Empresa(nome='{self.nome}', n_funcionarios={self.n_funcionarios})\"\n",
    "    \n",
    "    def contrata_funcionario(self, setor):\n",
    "        print(f\"Funcionário do setor {setor} contratado.\")\n",
    "        self.n_funcionarios += 1\n",
    "        \n",
    "    def demite_funcionario(self, setor):\n",
    "        if self.n_funcionarios == 0:\n",
    "            raise Exception('A empresa possui 0 funcionários. Assim, não é possível demitir ninguém.')\n",
    "        \n",
    "        print(f\"Funcionário do setor {setor} demitido.\")\n",
    "        self.n_funcionarios -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Empresa(nome='Py Consultoria', n_funcionarios=6)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py_consultoria = Empresa(nome='Py Consultoria', n_funcionarios=6)\n",
    "py_consultoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Como poderíamos definir uma classe chamada `Profissional` que mapearia um profissional do mundo real?\n",
    ">\n",
    "> Empresas contratam profissionais. O que teríamos que modificar na classe Empresa para que possamos identificar os profissionais contratados?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Herança "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na programação orientada a objetos, é possível que um objeto herde as propriedades de outros. \n",
    "\n",
    "No exemplo, anterior, criamos um objeto chamado `Empresa` que mapeava uma entidade do mundo real. Mas o objeto era um mapeamento bem genérico e não distinguia diferentes tipos de empresa. Para resolver isso, temos duas possíveis abordagens:\n",
    "\n",
    "1. Adicionar um atributo chamado `segmento`, por exemplo, que define o tipo da empresa.\n",
    "1. Criar objetos filhos os quais herdam do objeto pai `Empresa` e no qual podemos adicionar atributos a mais. \n",
    "\n",
    "Ambas são válidas, mas se utilizarmos a primeira solução ficaremos restritos aos mesmos métodos. Assim, vamos utilizar a segunda opção para criarmos objetos com diferentes propriedades."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos implementar um objeto que representa uma ecommerce. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ecommerce():\n",
    "    \n",
    "    def __init__(self, nome, n_produtos=0):\n",
    "        self.nome = nome\n",
    "        self.n_produtos = n_produtos\n",
    "    \n",
    "    def vende_produto(self, sku):\n",
    "        if self.n_produtos == 0:\n",
    "            raise Exception('A empresa possui 0 produtos. Assim, não é possível vender mais nada.')\n",
    "                      \n",
    "        print(f'Produto com SKU:{sku} vendido')\n",
    "        self.n_produtos -= 1\n",
    "        \n",
    "    def compra_produto(self, sku):\n",
    "        print(f'Produto com SKU:{sku} comprado')\n",
    "        self.n_productos += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Criamos o nosso objeto que representa um ecommerce e adicionamos algumas lógicas operacionais. Porém, não temos as lógicas de contratação e demissão de funcionários que nosso objeto `Empresa` possui. Para quue as propriedades de `Empresa` passem para `Ecommerce` utilizamos herança:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ecommerce(Empresa):\n",
    "    \n",
    "    def __init__(self, nome, n_funcionarios=0, n_produtos=0):\n",
    "        self.n_produtos = n_produtos\n",
    "        super().__init__(nome, n_funcionarios)\n",
    "    \n",
    "    def vende_produto(self, sku):\n",
    "        if self.n_produtos == 0:\n",
    "            raise Exception('A empresa possui 0 produtos. Assim, não é possível vender mais nada.')\n",
    "                      \n",
    "        print(f'Produto com SKU:{sku} vendido')\n",
    "        self.n_produtos -= 1\n",
    "        \n",
    "    def compra_produto(self, sku):\n",
    "        print(f'Produto com SKU:{sku} comprado')\n",
    "        self.n_productos += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Funcionário do setor RH contratado.\n",
      "Funcionário do setor Comercial demitido.\n",
      "Produto com SKU:BR123456 vendido\n"
     ]
    }
   ],
   "source": [
    "py_eshop = Ecommerce(nome='Py eShop', n_funcionarios=4, n_produtos=100)\n",
    "py_eshop.contrata_funcionario(setor='RH')\n",
    "py_eshop.demite_funcionario(setor='Comercial')\n",
    "py_eshop.vende_produto(sku='BR123456')"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}