Capítulo 15 - Classes e objetos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"readme\" class=\"Box-body readme blob instapaper_body js-code-block-container\">\n",
    "    <article class=\"markdown-body entry-content p-3 p-md-6\" itemprop=\"text\"><h1><a id=\"user-content-capítulo-15-classes-e-objetos\" class=\"anchor\" aria-hidden=\"true\" href=\"#capítulo-15-classes-e-objetos\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>Capítulo 15: Classes e objetos</h1>\n",
    "<p>A esta altura você já sabe como usar funções para organizar código e tipos integrados para organizar dados. O próximo passo é aprender “programação orientada a objeto”, que usa tipos definidos pelos programadores para organizar tanto o código quanto os dados. A programação orientada a objeto é um tópico abrangente; será preciso passar por alguns capítulos para abordar o tema.</p>\n",
    "<p>Os exemplos de código deste capítulo estão disponíveis em <a href=\"http://thinkpython2.com/code/Point1.py\" rel=\"nofollow\">http://thinkpython2.com/code/Point1.py</a>; as soluções para os exercícios estão disponíveis em <a href=\"http://thinkpython2.com/code/Point1_soln.py\" rel=\"nofollow\">http://thinkpython2.com/code/Point1_soln.py</a>.</p>\n",
    "<h2><a id=\"user-content-151---tipos-definidos-pelos-programadores\" class=\"anchor\" aria-hidden=\"true\" href=\"#151---tipos-definidos-pelos-programadores\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.1 - Tipos definidos pelos programadores</h2>\n",
    "<p>Já usamos muitos tipos integrados do Python; agora vamos definir um tipo próprio. Como exemplo, criaremos um tipo chamado <code>Point</code>, que representa um ponto no espaço bidimensional.</p>\n",
    "<p>Na notação matemática, os pontos muitas vezes são escritos entre parênteses, com uma vírgula separando as coordenadas. Por exemplo, (0,0) representa a origem e (x, y) representa o ponto que está x unidades à direita e y unidades acima da origem.</p>\n",
    "<p>Há várias formas para representar pontos no Python:</p>\n",
    "<ul>\n",
    "<li>\n",
    "<p>Podemos armazenar as coordenadas separadamente em duas variáveis, x e y.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Podemos armazenar as coordenadas como elementos em uma lista ou tupla.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Podemos criar um tipo para representar pontos como objetos.</p>\n",
    "</li>\n",
    "</ul>\n",
    "<p>Criar um tipo é mais complicado que outras opções, mas tem vantagens que logo ficarão evidentes.</p>\n",
    "<p>Um tipo definido pelo programador também é chamado de <b>classe</b>. Uma definição de classe pode ser assim:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    \"\"\"Represents a point in 2-D space.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>O cabeçalho indica que a nova classe se chama <code>Point</code>. O corpo é uma docstring que explica para que a classe serve. Você pode definir variáveis e métodos dentro de uma definição de classe, mas voltaremos a isso depois.</p>\n",
    "<p>Definir uma classe denominada <code>Point</code> cria um <b>objeto de classe</b>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Point"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> Point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Como <code>Point</code> é definido no nível superior, seu “nome completo” é <code>__main__.Point</code>.</p>\n",
    "<p>O objeto de classe é como uma fábrica para criar objetos. Para criar um <code>Point</code>, você chama <code>Point</code> como se fosse uma função:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Point at 0x7f1bb8560e48>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> blank = Point()\n",
    ">>> blank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>O valor de retorno é uma referência a um objeto <code>Point</code>, que atribuímos a <code>blank</code>.</p>\n",
    "<p>Criar um objeto chama-se <b>instanciação</b>, e o objeto é uma <b>instância</b> da classe.</p>\n",
    "<p>Quando você exibe uma instância, o Python diz a que classe ela pertence e onde está armazenada na memória (o prefixo 0x significa que o número seguinte está em formato hexadecimal).</p>\n",
    "<p>Cada objeto é uma instância de alguma classe, então “objeto” e “instância” são intercambiáveis. Porém, neste capítulo uso “instância” para indicar que estou falando sobre um tipo definido pelo programador.</p>\n",
    "<h2><a id=\"user-content-152---atributos\" class=\"anchor\" aria-hidden=\"true\" href=\"#152---atributos\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.2 - Atributos</h2>\n",
    "<p>Você pode atribuir valores a uma instância usando a notação de ponto:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> blank.x = 3.0\n",
    ">>> blank.y = 4.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Essa sintaxe é semelhante à usada para selecionar uma variável de um módulo, como <code>math.pi</code> ou <code>string.whitespace</code>. Nesse caso, entretanto, estamos atribuindo valores a elementos nomeados de um objeto. Esses elementos chamam-se <b>atributos</b>.</p>\n",
    "<p>Em inglês, quando é um substantivo, a palavra “AT-trib-ute” é pronunciada com ênfase na primeira sílaba, ao contrário de “a-TRIB-ute”, que é um verbo.</p>\n",
    "<p>O diagrama seguinte mostra o resultado dessas atribuições. Um diagrama de estado que mostra um objeto e seus atributos chama-se <b>diagrama de objeto</b>; veja a Figura 15.1.</p>\n",
    "<p><a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1501.png\"><img src=\"https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1501.png\" alt=\"Figura 15.1 – Diagrama de um objeto Point.\" style=\"max-width:100%;\"></a>\n",
    "<br><em>Figura 15.1 – Diagrama de um objeto</em> <code>Point</code>.</p>\n",
    "<p>A variável <code>blank</code> refere-se a um objeto <code>Point</code>, que contém dois atributos. Cada atributo refere-se a um número de ponto flutuante.</p>\n",
    "<p>Você pode ler o valor de um atributo usando a mesma sintaxe:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> blank.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> x = blank.x\n",
    ">>> x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>A expressão <code>blank.x</code> significa “Vá ao objeto a que <code>blank</code> se refere e pegue o valor de <code>x</code>”. No exemplo, atribuímos este valor a uma variável <code>x</code>. Não há nenhum conflito entre a variável <code>x</code> e o atributo <code>x</code>.</p>\n",
    "<p>Você pode usar a notação de ponto como parte de qualquer expressão. Por exemplo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(3, 4)'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> '(%g, %g)' % (blank.x, blank.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> import math\n",
    ">>> distance = math.sqrt(blank.x ** 2 + blank.y **2)\n",
    ">>> distance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Você pode passar uma instância como argumento da forma habitual. Por exemplo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_point(p):\n",
    "    print('(%g, %g)' % (p.x, p.y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><code>print_point</code> toma um ponto como argumento e o exibe em notação matemática. Para invocá-lo, você pode passar <code>blank</code> como argumento:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    ">>> print_point(blank)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Dentro da função, <code>p</code> é um <i>alias</i> para <code>blank</code>, então, se a função altera <code>p</code>, <code>blank</code> também muda.</p>\n",
    "<p>Como exercício, escreva uma função chamada <code>distance_between_points</code>, que toma dois pontos como argumentos e retorna a distância entre eles.</p>\n",
    "<h2><a id=\"user-content-153---retângulos\" class=\"anchor\" aria-hidden=\"true\" href=\"#153---retângulos\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.3 - Retângulos</h2>\n",
    "<p>Às vezes, é óbvio quais deveriam ser os atributos de um objeto, mas outras é preciso decidir entre as possibilidades. Por exemplo, vamos supor que você esteja criando uma classe para representar retângulos. Que atributos usaria para especificar a posição e o tamanho de um retângulo? Você pode ignorar ângulo; para manter as coisas simples, suponha que o retângulo seja vertical ou horizontal.</p>\n",
    "<p>Há duas possibilidades, no mínimo:</p>\n",
    "<ul>\n",
    "<li>\n",
    "<p>Você pode especificar um canto do retângulo (ou o centro), a largura e a altura.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Você pode especificar dois cantos opostos.</p>\n",
    "</li>\n",
    "</ul>\n",
    "<p>Nesse ponto é difícil dizer qual opção é melhor, então implementaremos a primeira, como exemplo.</p>\n",
    "<p>Aqui está a definição de classe:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    \"\"\"Represents a rectangle.\n",
    "    \n",
    "    attributes: width, height, corner.\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>A <i>docstring</i> lista os atributos: <code>width</code> e <code>height</code> são números; <code>corner</code> é um objeto <code>Point</code> que especifica o canto inferior esquerdo.</p>\n",
    "<p>Para representar um retângulo, você tem que instanciar um objeto <code>Rectangle</code> e atribuir valores aos atributos:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "box = Rectangle()\n",
    "box.width = 100.0\n",
    "box.height = 200.0\n",
    "box.corner = Point()\n",
    "box.corner.x = 0.0\n",
    "box.corner.y = 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>A expressão <code>box.corner.x</code> significa “Vá ao objeto ao qual <code>box</code> se refere e pegue o atributo denominado <code>corner</code>; então vá a este objeto e pegue o atributo denominado <code>x</code>”.</p>\n",
    "<p>A Figura 15.2 mostra o estado deste objeto. Um objeto que é um atributo de outro objeto é <b>integrado</b>.</p>\n",
    "<p><a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1502.png\"><img src=\"https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1502.png\" alt=\"Figura 15.2 – Diagrama de um objeto Rectangle.\" style=\"max-width:100%;\"></a>\n",
    "<br><em>Figura 15.2 – Diagrama de um objeto</em> <code>Rectangle</code>.</p>\n",
    "<h2><a id=\"user-content-154---instâncias-como-valores-de-retorno\" class=\"anchor\" aria-hidden=\"true\" href=\"#154---instâncias-como-valores-de-retorno\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.4 - Instâncias como valores de retorno</h2>\n",
    "<p>As funções podem retornar instâncias. Por exemplo, <code>find_center</code> recebe um <code>Rectangle</code> como argumento e devolve um <code>Point</code>, que contém as coordenadas do centro do retângulo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_center(rect):\n",
    "    p = Point()\n",
    "    p.x = rect.corner.x + rect.width/2\n",
    "    p.y = rect.corner.y + rect.height/2\n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Aqui está um exemplo que passa <code>box</code> como um argumento para <code>find_center</code> e atribui o <code>Point</code> resultante à variável <code>center</code>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50, 100)\n"
     ]
    }
   ],
   "source": [
    ">>> center = find_center(box)\n",
    ">>> print_point(center)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><a id=\"user-content-155---objetos-são-mutáveis\" class=\"anchor\" aria-hidden=\"true\" href=\"#155---objetos-são-mutáveis\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.5 - Objetos são mutáveis</h2>\n",
    "<p>Você pode alterar o estado de um objeto fazendo uma atribuição a um dos seus atributos. Por exemplo, para mudar o tamanho de um retângulo sem mudar sua posição, você pode alterar os valores de <code>width</code> e <code>height</code>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "box.width = box.width + 50\n",
    "box.height = box.height + 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Você também pode escrever funções que alteram objetos. Por exemplo, <code>grow_rectangle</code> recebe um objeto <code>Rectangle</code> e dois números, <code>dwidth</code> e <code>dheight</code>, e adiciona os números à largura e altura do retângulo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grow_rectangle(rect, dwidth, dheight):\n",
    "    rect.width += dwidth\n",
    "    rect.height += dheight"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Eis um exemplo que demonstra o efeito:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150.0, 300.0)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> box.width, box.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200.0, 400.0)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> grow_rectangle(box, 50, 100)\n",
    ">>> box.width, box.height"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Dentro da função, <code>rect</code> é um <i>alias</i> de <code>box</code>, então quando a função altera <code>rect</code>, <code>box</code> aponta para o objeto alterado.</p>\n",
    "<p>Como exercício, escreva uma função chamada <code>move_rectangle</code> que toma um Rectangle e dois números chamados <code>dx</code> e <code>dy</code>. Ela deve alterar a posição do retângulo, adicionando <code>dx</code> à coordenada <code>x</code> de <code>corner</code> e adicionando <code>dy</code> à coordenada <code>y</code> de <code>corner</code>.</p>\n",
    "<h2><a id=\"user-content-156---cópia\" class=\"anchor\" aria-hidden=\"true\" href=\"#156---cópia\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.6 - Cópia</h2>\n",
    "<p><i>Alias</i> podem tornar um programa difícil de ler porque as alterações em um lugar podem ter efeitos inesperados em outro lugar. É difícil monitorar todas as variáveis que podem referir-se a um dado objeto.</p>\n",
    "<p>Em vez de usar <i>alias</i>, copiar o objeto pode ser uma alternativa. O módulo <code>copy</code> contém uma função chamada <code>copy</code> que pode duplicar qualquer objeto:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> p1 = Point()\n",
    ">>> p1.x = 3.0\n",
    ">>> p1.y = 4.0\n",
    ">>> import copy\n",
    ">>> p2 = copy.copy(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><code>p1</code> e <code>p2</code> contêm os mesmos dados, mas não são o mesmo <code>Point</code>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    ">>> print_point(p1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    ">>> print_point(p2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> p1 is p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> p1 == p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>O operador <code>is</code> indica que <code>p1</code> e <code>p2</code> não são o mesmo objeto, que é o que esperamos. Porém, você poderia ter esperado que <code>==</code> fosse apresentado como <code>True</code>, porque esses pontos contêm os mesmos dados. Nesse caso, pode ficar desapontado ao saber que, para instâncias, o comportamento padrão do operador <code>==</code> é o mesmo que o do operador <code>is</code>; ele verifica a identidade dos objetos, não a sua equivalência. Isso acontece porque, para tipos definidos pelo programador, o Python não sabe o que deve ser considerado equivalente. Pelo menos, ainda não.</p>\n",
    "<p>Se você usar <code>copy.copy</code> para duplicar um retângulo, descobrirá que ele copia o objeto <code>Rectangle</code>, mas não o <code>Point</code> embutido nele:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> box2 = copy.copy(box)\n",
    ">>> box2 is box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> box2.corner is box.corner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>A Figura 15.3 mostra como fica o diagrama de objeto. Esta operação chama-se <b>cópia superficial</b> porque copia o objeto e qualquer referência que contenha, mas não os objetos integrados.</p>\n",
    "<p><a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1503.png\"><img src=\"https://github.com/PenseAllen/PensePython2e/raw/master/fig/tnkp_1503.png\" alt=\"Figura 15.3 – Diagrama: dois objetos Rectangle compartilhando o mesmo Point.\" style=\"max-width:100%;\"></a>\n",
    "<br><em>Figura 15.3 – Diagrama: dois objetos</em> <code>Rectangle</code> <em>compartilhando o mesmo</em> <code>Point</code>.</p>\n",
    "<p>Para a maior parte das aplicações, não é isso que você quer. Nesse exemplo, invocar <code>grow_rectangle</code> em um dos <code>Rectangle</code>s não afetaria o outro, mas invocar <code>move_rectangle</code> em qualquer um deles afetaria a ambos! Esse comportamento é confuso e propenso a erros.</p>\n",
    "<p>Felizmente, o módulo <code>copy</code> oferece um método chamado <code>deepcopy</code> que copia não só o objeto, mas também os objetos aos quais ele se refere, e os objetos aos quais estes se referem, e assim por diante. Você não se surpreenderá ao descobrir que esta operação se chama <b>cópia profunda</b>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> box3 = copy.deepcopy(box)\n",
    ">>> box3 is box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> box3.corner is box.corner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>box3</code> e <code>box</code> são objetos completamente separados.</pre></div>\n",
    "<p>Como exercício, escreva uma versão de <code>move_rectangle</code> que cria e retorne um novo retângulo em vez de alterar o antigo.</p>\n",
    "<h2><a id=\"user-content-157---depuração\" class=\"anchor\" aria-hidden=\"true\" href=\"#157---depuração\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.7 - Depuração</h2>\n",
    "<p>Ao começar a trabalhar com objetos, provavelmente você encontrará algumas novas exceções. Se tentar acessar um atributo que não existe, recebe um <code>AttributeError</code>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Point' object has no attribute 'z'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-60-7ffb705a99ef>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Point' object has no attribute 'z'"
     ]
    }
   ],
   "source": [
    ">>> p = Point()\n",
    ">>> p.x = 3\n",
    ">>> p.y = 4\n",
    ">>> p.z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Se não estiver certo sobre o tipo que um objeto é, pode perguntar:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Point"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> type(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Você também pode usar <code>isinstance</code> para verificar se um objeto é uma instância de uma classe:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> isinstance(p, Point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Caso não tenha certeza se um objeto tem determinado atributo, você pode usar a função integrada <code>hasattr</code>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> hasattr(p, 'x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> hasattr(p, 'z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>O primeiro argumento pode ser qualquer objeto; o segundo argumento é uma <code>string</code> com o nome do atributo.</p>\n",
    "<p>Você também pode usar uma instrução <code>try</code> para ver se o objeto tem os atributos de que precisa:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    x = p.x\n",
    "except AttributeError:\n",
    "    x = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Essa abordagem pode facilitar a escrita de funções que atuam com tipos diferentes; você verá mais informações sobre isso em “Polimorfismo”, no Capítulo 17.</p>\n",
    "<h2><a id=\"user-content-158---glossário\" class=\"anchor\" aria-hidden=\"true\" href=\"#158---glossário\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.8 - Glossário</h2>\n",
    "<dl>\n",
    "<dt><a id=\"user-content-glos:classe\"><b>classe</b></a></dt>\n",
    "<dd>Tipo definido pelo programador. Uma definição de classe cria um objeto de classe.</dd>\n",
    "<dt><a id=\"user-content-glos:objeto de classe\"><b>objeto de classe</b></a></dt>\n",
    "<dd>Objeto que contém a informação sobre um tipo definido pelo programador. O objeto de classe pode ser usado para criar instâncias do tipo.</dd>\n",
    "<dt><a id=\"user-content-glos:instância\"><b>instância</b></a></dt>\n",
    "<dd>Objeto que pertence a uma classe.</dd>\n",
    "<dt><a id=\"user-content-glos:instanciar\"><b>instanciar</b></a></dt>\n",
    "<dd>Criar um objeto.</dd>\n",
    "<dt><a id=\"user-content-glos:atributo\"><b>atributo</b></a></dt>\n",
    "<dd>Um dos valores denominados associados a um objeto.</dd>\n",
    "<dt><a id=\"user-content-glos:objeto integrado\"><b>objeto integrado</b></a></dt>\n",
    "<dd>Objeto que é armazenado como um atributo de outro objeto.</dd>\n",
    "<dt><a id=\"user-content-glos:cópia superficial\"><b>cópia superficial</b></a></dt>\n",
    "<dd>Copiar o conteúdo de um objeto, inclusive qualquer referência a objetos integrados; implementada pela função copy no módulo copy.</dd>\n",
    "<dt><a id=\"user-content-glos:cópia profunda\"><b>cópia profunda</b></a></dt>\n",
    "<dd>Copiar o conteúdo de um objeto, bem como qualquer objeto integrado, e qualquer objeto integrado a estes, e assim por diante; implementado pela função deepcopy no módulo copy.</dd>\n",
    "<dt><a id=\"user-content-glos:diagrama de objeto\"><b>diagrama de objeto</b></a></dt>\n",
    "<dd>Diagrama que mostra objetos, seus atributos e os valores dos atributos.</dd>\n",
    "</dl>\n",
    "<h2><a id=\"user-content-159---exercícios\" class=\"anchor\" aria-hidden=\"true\" href=\"#159---exercícios\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>15.9 - Exercícios</h2>\n",
    "<h3><a id=\"user-content-exercício-151\" class=\"anchor\" aria-hidden=\"true\" href=\"#exercício-151\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>Exercício 15.1</h3>\n",
    "<ol>\n",
    "<li>\n",
    "<p>Escreva uma definição para uma classe denominada <code>Circle</code>, com os atributos <code>center</code> e <code>radius</code>, onde <code>center</code> é um objeto <code>Point</code> e <code>radius</code> é um número.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Instancie um objeto <code>Circle</code>, que represente um círculo com o centro em 150, 100 e raio 75.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Escreva uma função denominada <code>point_in_circle</code>, que tome um <code>Circle</code> e um <code>Point</code> e retorne <code>True</code>, se o ponto estiver dentro ou no limite do círculo.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Escreva uma função chamada <code>rect_in_circle</code>, que tome um <code>Circle</code> e um <code>Rectangle</code> e retorne <code>True</code>, se o retângulo estiver totalmente dentro ou no limite do círculo.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Escreva uma função denominada <code>rect_circle_overlap</code>, que tome um <code>Circle</code> e um <code>Rectangle</code> e retorne <code>True</code>, se algum dos cantos do retângulo cair dentro do círculo. Ou, em uma versão mais desafiadora, retorne <code>True</code> se alguma parte do retângulo cair dentro do círculo.</p>\n",
    "</li>\n",
    "</ol>\n",
    "<p>Solução: <a href=\"http://thinkpython2.com/code/Circle.py\" rel=\"nofollow\">http://thinkpython2.com/code/Circle.py</a>.</p>\n",
    "<h3><a id=\"user-content-exercício-152\" class=\"anchor\" aria-hidden=\"true\" href=\"#exercício-152\"><svg class=\"octicon octicon-link\" viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path fill-rule=\"evenodd\" d=\"M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z\"></path></svg></a>Exercício 15.2</h3>\n",
    "<ol>\n",
    "<li>\n",
    "<p>Escreva uma função chamada <code>draw_rect</code> que receba um objeto <code>Turtle</code> e um <code>Rectangle</code> e use o <code>Turtle</code> para desenhar o retângulo. Veja no Capítulo 4 os exemplos de uso de objetos <code>Turtle</code>.</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>Escreva uma função chamada <code>draw_circle</code>, que tome um <code>Turtle</code> e um <code>Circle</code> e desenhe o círculo.</p>\n",
    "</li>\n",
    "</ol>"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}