{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "[Python para Desenvolvedores](http://ricardoduarte.github.io/python-para-desenvolvedores/#conteudo)\n",
      "===================================\n",
      "2ª edi\u00e7\u00e3o, revisada e ampliada\n",
      "-----------------------------------\n",
      "\n",
      "Respostas dos exerc\u00edcios IV\n",
      "=============================\n",
      "_____________________________\n",
      "1\\. Crie uma classe que modele um quadrado, com um atributo lado e os m\u00e9todos: mudar valor do lado, retornar valor do lado e calcular \u00e1rea.\n",
      "\n",
      "Solu\u00e7\u00e3o:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Square(object):\n",
      "    \"\"\"\n",
      "    Classe que modela um quadrado.\n",
      "    \"\"\"\n",
      "\n",
      "    def __init__(self, side=1):\n",
      "\n",
      "        self.side = side\n",
      "\n",
      "    def get_side(self):\n",
      "\n",
      "        return self.side\n",
      "    \n",
      "    def set_side(self, side):\n",
      "\n",
      "        self.side = side\n",
      "    \n",
      "    def get_area(self):\n",
      "\n",
      "        # A \u00e1rea \u00e9 o quadrado do lado\n",
      "        return self.side ** 2\n",
      "\n",
      "# Testes\n",
      "square = Square(2)\n",
      "square.set_side(3)\n",
      "print square.get_area()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "9\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "2\\. Crie uma classe derivada de lista com um m\u00e9todo retorne os elementos da lista sem repeti\u00e7\u00e3o.\n",
      "\n",
      "Solu\u00e7\u00e3o:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class List(list):\n",
      "\n",
      "    def unique(self):\n",
      "        \"\"\"\n",
      "        Retorna a lista sem repeti\u00e7\u00f5es.\n",
      "        \"\"\"\n",
      "\n",
      "        res = []\n",
      "        for item in self:\n",
      "\n",
      "            if item not in res:\n",
      "                res.append(item)\n",
      "\n",
      "        return res\n",
      "\n",
      "# Teste\n",
      "l = List([1, 1, 2, 2, 2, 3, 3])\n",
      "\n",
      "print l.unique()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 3]\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "3\\. Implemente uma classe *Carro* com as seguintes propriedades:\n",
      "\n",
      "+ Um ve\u00edculo tem um certo consumo de combust\u00edvel (medidos em km / litro) e uma certa quantidade de combust\u00edvel no tanque.\n",
      "+ O consumo \u00e9 especificado no construtor e o n\u00edvel de combust\u00edvel inicial \u00e9 0.\n",
      "+ Forne\u00e7a um m\u00e9todo `mover(km)` que receba a dist\u00e2ncia em quil\u00f4metros e reduza o n\u00edvel de combust\u00edvel no tanque de gasolina.\n",
      "+ Forne\u00e7a um m\u00e9todo `gasolina()`, que retorna o n\u00edvel atual de combust\u00edvel.\n",
      "+ Forne\u00e7a um m\u00e9todo `abastecer(litros)`, para abastecer o tanque.\n",
      "\n",
      "Solu\u00e7\u00e3o:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Carro(object):\n",
      "    \"\"\"\n",
      "    Classe que calcula o consumo de um carro.\n",
      "    \"\"\"\n",
      "\n",
      "    tanque = 0\n",
      "\n",
      "    def __init__(self, consumo):\n",
      "\n",
      "        self.consumo = consumo\n",
      "\n",
      "    def mover(self, km):\n",
      "\n",
      "        gasto = self.consumo * km\n",
      "\n",
      "        if self.tanque > gasto:\n",
      "            self.tanque = self.tanque - gasto\n",
      "        else:\n",
      "            self.tanque = 0\n",
      "\n",
      "    def abastecer(self, litros):\n",
      "\n",
      "        self.tanque = self.tanque + litros\n",
      "\n",
      "    def gasolina(self):\n",
      "\n",
      "        return self.tanque\n",
      "\n",
      "# Teste\n",
      "carro = Carro(consumo=5)\n",
      "carro.abastecer(litros=220)\n",
      "carro.mover(km=20)\n",
      "print carro.gasolina()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "120\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "4\\. Implementar uma classe *Vetor*:\n",
      "\n",
      "+ Com coordenadas x, y e z.\n",
      "+ Que suporte soma, subtra\u00e7\u00e3o, produto escalar e produto vetorial.\n",
      "+ Que calcule o m\u00f3dulo (valor absoluto) do vetor.\n",
      "\n",
      "Solu\u00e7\u00e3o:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "class Vetor(object):\n",
      "\n",
      "    def __init__(self, x, y, z):\n",
      "\n",
      "        self.x = float(x)\n",
      "        self.y = float(y)\n",
      "        self.z = float(z)\n",
      "\n",
      "    def __repr__(self):\n",
      "\n",
      "        return 'Vetor(x=%.1f, y=%.1f, z=%.1f)' % (self.x, self.y, self.z)\n",
      "        \n",
      "    def __add__(self, v):\n",
      "\n",
      "        x = self.x + v.x\n",
      "        y = self.y + v.y\n",
      "        z = self.z + v.z\n",
      "        return Vetor(x, y, z)\n",
      "\n",
      "    def __sub__(self, v):\n",
      "\n",
      "        x = self.x - v.x\n",
      "        y = self.y - v.y\n",
      "        z = self.z - v.z\n",
      "        return Vetor(x, y, z)\n",
      "\n",
      "    def __abs__(self):\n",
      "\n",
      "        tmp = self.x ** 2 + self.y ** 2 + self.z ** 2\n",
      "        return math.sqrt(tmp)\n",
      "\n",
      "    def __mul__(self, v):\n",
      "\n",
      "        if isinstance(v, Vetor):\n",
      "            x = self.y * v.z - v.y * self.z\n",
      "            y = self.z * v.x - v.z * self.x\n",
      "            z = self.x * v.y - v.x * self.y\n",
      "        else:\n",
      "            x = self.x * float(v)\n",
      "            y = self.y * float(v)\n",
      "            z = self.z * float(v)\n",
      "        return Vetor(x, y, z)\n",
      "\n",
      "vetor = Vetor(1, 2, 3)\n",
      "\n",
      "print abs(vetor)\n",
      "print Vetor(4.5, 5, 6) + vetor\n",
      "print Vetor(4.5, 5, 6) - vetor\n",
      "print Vetor(4.5, 5, 6) * vetor\n",
      "print Vetor(4.5, 5, 6) * 5"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3.74165738677\n",
        "Vetor(x=5.5, y=7.0, z=9.0)\n",
        "Vetor(x=3.5, y=3.0, z=3.0)\n",
        "Vetor(x=3.0, y=-7.5, z=4.0)\n",
        "Vetor(x=22.5, y=25.0, z=30.0)\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "5\\. Implemente um m\u00f3dulo com:\n",
      "\n",
      "+ Uma classe Ponto, com coordenadas x, y e z.\n",
      "+ Uma classe Linha, com dois pontos A e B, e que calcule o comprimento da linha.\n",
      "+ Uma classe Triangulo, com dois pontos A, B e C, que calcule o comprimento dos lados e a \u00e1rea.\n",
      "\n",
      "Solu\u00e7\u00e3o:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Ponto(object):\n",
      "\n",
      "    def __init__(self, x, y, z):\n",
      "\n",
      "        # Coordenadas\n",
      "        self.x = float(x)\n",
      "        self.y = float(y)\n",
      "        self.z = float(z)\n",
      "        \n",
      "    def __repr__(self):\n",
      "        \n",
      "        return '(%2.1f, %2.1f, %2.1f)' % \\\n",
      "        (self.x, self.y, self.z)\n",
      "\n",
      "class Linha(object):\n",
      "    \n",
      "    def __init__(self, a, b):\n",
      "\n",
      "        # Pontos\n",
      "        self.a = a\n",
      "        self.b = b\n",
      "\n",
      "    def comp(self):\n",
      "\n",
      "        x = self.b.x - self.a.x\n",
      "        y = self.b.y - self.a.y\n",
      "        z = self.b.z - self.a.z\n",
      "        \n",
      "        return round((x ** 2 + y ** 2 + z ** 2)\\\n",
      "            ** .5, 1)\n",
      "\n",
      "    def __repr__(self):\n",
      "        \n",
      "        return '%s => %s' % \\\n",
      "        (self.a, self.b)\n",
      "\n",
      "class Triangulo(object):\n",
      "\n",
      "    def __init__(self, a, b, c):\n",
      "\n",
      "        # Vertices\n",
      "        self.a = a\n",
      "        self.b = b\n",
      "        self.c = c\n",
      "\n",
      "        # Lados\n",
      "        self.ab = Linha(a, b)\n",
      "        self.bc = Linha(b, c)\n",
      "        self.ca = Linha(c, a)\n",
      "\n",
      "    def area(self):\n",
      "\n",
      "        # Comprimento dos lados\n",
      "        ab = self.ab.comp()\n",
      "        bc = self.bc.comp()\n",
      "        ca = self.ca.comp()\n",
      "\n",
      "        # Semiperimetro\n",
      "        p = (ab + bc + ca) / 2.\n",
      "\n",
      "        # Teorema de Heron\n",
      "        return round((p * (p - ab) * (p - bc) \\\n",
      "            * (p - ca)) ** .5, 1)\n",
      "\n",
      "    def __repr__(self):\n",
      "\n",
      "        return '%s => %s => %s)' % \\\n",
      "        (self.a, self.b, self.c)\n",
      "\n",
      "# Testes\n",
      "a = Ponto(2, 3, 1)\n",
      "b = Ponto(5, 1, 4)\n",
      "c = Ponto(4, 2, 5)\n",
      "l = Linha(a, b)\n",
      "t = Triangulo(a, b, c)\n",
      "\n",
      "print 'Ponto A:', a\n",
      "print 'Ponto B:', b\n",
      "print 'Ponto C:', c\n",
      "print 'Linha:', l\n",
      "print 'Comprimento:', l.comp()\n",
      "print 'Triangulo:', t\n",
      "print 'Area:', t.area()\n",
      "\n",
      "# Mostra:\n",
      "# Ponto A: (2.0, 3.0, 1.0)\n",
      "# Ponto B: (5.0, 1.0, 4.0)\n",
      "# Ponto C: (4.0, 2.0, 5.0)\n",
      "# Linha: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0)\n",
      "# Comprimento: 4.7\n",
      "# Triangulo: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0) => (4.0, 2.0, 5.0))\n",
      "# Area: 3.9"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Ponto A: (2.0, 3.0, 1.0)\n",
        "Ponto B: (5.0, 1.0, 4.0)\n",
        "Ponto C: (4.0, 2.0, 5.0)\n",
        "Linha: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0)\n",
        "Comprimento: 4.7\n",
        "Triangulo: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0) => (4.0, 2.0, 5.0))\n",
        "Area: 3.9\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "<style>\n",
        "    @font-face {\n",
        "        font-family: \"Computer Modern\";\n",
        "        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
        "    }\n",
        "    div.cell{\n",
        "        width:800px;\n",
        "        margin-left:16% !important;\n",
        "        margin-right:auto;\n",
        "    }\n",
        "    h1 {\n",
        "        font-family: Helvetica, serif;\n",
        "    }\n",
        "    h4{\n",
        "        margin-top:12px;\n",
        "        margin-bottom: 3px;\n",
        "       }\n",
        "    div.text_cell_render{\n",
        "        font-family: Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
        "        line-height: 145%;\n",
        "        font-size: 130%;\n",
        "        width:800px;\n",
        "        margin-left:auto;\n",
        "        margin-right:auto;\n",
        "    }\n",
        "    .CodeMirror{\n",
        "            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n",
        "    }\n",
        "    .note{\n",
        "            border-bottom: 1px black dotted;\n",
        "    }\n",
        "    .prompt{\n",
        "        display: None;\n",
        "    }\n",
        "    .text_cell_render h5 {\n",
        "        font-weight: 300;\n",
        "        font-size: 16pt;\n",
        "        color: #4057A1;\n",
        "        font-style: italic;\n",
        "        margin-bottom: .5em;\n",
        "        margin-top: 0.5em;\n",
        "        display: block;\n",
        "    }\n",
        "    \n",
        "    .warning{\n",
        "        color: rgb( 240, 20, 20 )\n",
        "        }  \n",
        "</style>\n",
        "<script>\n",
        "    MathJax.Hub.Config({\n",
        "                        TeX: {\n",
        "                           extensions: [\"AMSmath.js\"]\n",
        "                           },\n",
        "                tex2jax: {\n",
        "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
        "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
        "                },\n",
        "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
        "                \"HTML-CSS\": {\n",
        "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
        "                }\n",
        "        });\n",
        "</script>"
       ],
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "<IPython.core.display.HTML at 0x50f8f98>"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}