Python para Desenvolvedores

2ª edição, revisada e ampliada

Respostas dos exercícios IV


1. Crie uma classe que modele um quadrado, com um atributo lado e os métodos: mudar valor do lado, retornar valor do lado e calcular área.

Solução:

In [1]:
class Square(object):
    """
    Classe que modela um quadrado.
    """

    def __init__(self, side=1):

        self.side = side

    def get_side(self):

        return self.side
    
    def set_side(self, side):

        self.side = side
    
    def get_area(self):

        # A área é o quadrado do lado
        return self.side ** 2

# Testes
square = Square(2)
square.set_side(3)
print square.get_area()
9

2. Crie uma classe derivada de lista com um método retorne os elementos da lista sem repetição.

Solução:

In [2]:
class List(list):

    def unique(self):
        """
        Retorna a lista sem repetições.
        """

        res = []
        for item in self:

            if item not in res:
                res.append(item)

        return res

# Teste
l = List([1, 1, 2, 2, 2, 3, 3])

print l.unique()
[1, 2, 3]

3. Implemente uma classe Carro com as seguintes propriedades:

  • Um veículo tem um certo consumo de combustível (medidos em km / litro) e uma certa quantidade de combustível no tanque.
  • O consumo é especificado no construtor e o nível de combustível inicial é 0.
  • Forneça um método mover(km) que receba a distância em quilômetros e reduza o nível de combustível no tanque de gasolina.
  • Forneça um método gasolina(), que retorna o nível atual de combustível.
  • Forneça um método abastecer(litros), para abastecer o tanque.

Solução:

In [3]:
class Carro(object):
    """
    Classe que calcula o consumo de um carro.
    """

    tanque = 0

    def __init__(self, consumo):

        self.consumo = consumo

    def mover(self, km):

        gasto = self.consumo * km

        if self.tanque > gasto:
            self.tanque = self.tanque - gasto
        else:
            self.tanque = 0

    def abastecer(self, litros):

        self.tanque = self.tanque + litros

    def gasolina(self):

        return self.tanque

# Teste
carro = Carro(consumo=5)
carro.abastecer(litros=220)
carro.mover(km=20)
print carro.gasolina()
120

4. Implementar uma classe Vetor:

  • Com coordenadas x, y e z.
  • Que suporte soma, subtração, produto escalar e produto vetorial.
  • Que calcule o módulo (valor absoluto) do vetor.

Solução:

In [4]:
import math

class Vetor(object):

    def __init__(self, x, y, z):

        self.x = float(x)
        self.y = float(y)
        self.z = float(z)

    def __repr__(self):

        return 'Vetor(x=%.1f, y=%.1f, z=%.1f)' % (self.x, self.y, self.z)
        
    def __add__(self, v):

        x = self.x + v.x
        y = self.y + v.y
        z = self.z + v.z
        return Vetor(x, y, z)

    def __sub__(self, v):

        x = self.x - v.x
        y = self.y - v.y
        z = self.z - v.z
        return Vetor(x, y, z)

    def __abs__(self):

        tmp = self.x ** 2 + self.y ** 2 + self.z ** 2
        return math.sqrt(tmp)

    def __mul__(self, v):

        if isinstance(v, Vetor):
            x = self.y * v.z - v.y * self.z
            y = self.z * v.x - v.z * self.x
            z = self.x * v.y - v.x * self.y
        else:
            x = self.x * float(v)
            y = self.y * float(v)
            z = self.z * float(v)
        return Vetor(x, y, z)

vetor = Vetor(1, 2, 3)

print abs(vetor)
print Vetor(4.5, 5, 6) + vetor
print Vetor(4.5, 5, 6) - vetor
print Vetor(4.5, 5, 6) * vetor
print Vetor(4.5, 5, 6) * 5
3.74165738677
Vetor(x=5.5, y=7.0, z=9.0)
Vetor(x=3.5, y=3.0, z=3.0)
Vetor(x=3.0, y=-7.5, z=4.0)
Vetor(x=22.5, y=25.0, z=30.0)

5. Implemente um módulo com:

  • Uma classe Ponto, com coordenadas x, y e z.
  • Uma classe Linha, com dois pontos A e B, e que calcule o comprimento da linha.
  • Uma classe Triangulo, com dois pontos A, B e C, que calcule o comprimento dos lados e a área.

Solução:

In [5]:
class Ponto(object):

    def __init__(self, x, y, z):

        # Coordenadas
        self.x = float(x)
        self.y = float(y)
        self.z = float(z)
        
    def __repr__(self):
        
        return '(%2.1f, %2.1f, %2.1f)' % \
        (self.x, self.y, self.z)

class Linha(object):
    
    def __init__(self, a, b):

        # Pontos
        self.a = a
        self.b = b

    def comp(self):

        x = self.b.x - self.a.x
        y = self.b.y - self.a.y
        z = self.b.z - self.a.z
        
        return round((x ** 2 + y ** 2 + z ** 2)\
            ** .5, 1)

    def __repr__(self):
        
        return '%s => %s' % \
        (self.a, self.b)

class Triangulo(object):

    def __init__(self, a, b, c):

        # Vertices
        self.a = a
        self.b = b
        self.c = c

        # Lados
        self.ab = Linha(a, b)
        self.bc = Linha(b, c)
        self.ca = Linha(c, a)

    def area(self):

        # Comprimento dos lados
        ab = self.ab.comp()
        bc = self.bc.comp()
        ca = self.ca.comp()

        # Semiperimetro
        p = (ab + bc + ca) / 2.

        # Teorema de Heron
        return round((p * (p - ab) * (p - bc) \
            * (p - ca)) ** .5, 1)

    def __repr__(self):

        return '%s => %s => %s)' % \
        (self.a, self.b, self.c)

# Testes
a = Ponto(2, 3, 1)
b = Ponto(5, 1, 4)
c = Ponto(4, 2, 5)
l = Linha(a, b)
t = Triangulo(a, b, c)

print 'Ponto A:', a
print 'Ponto B:', b
print 'Ponto C:', c
print 'Linha:', l
print 'Comprimento:', l.comp()
print 'Triangulo:', t
print 'Area:', t.area()

# Mostra:
# Ponto A: (2.0, 3.0, 1.0)
# Ponto B: (5.0, 1.0, 4.0)
# Ponto C: (4.0, 2.0, 5.0)
# Linha: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0)
# Comprimento: 4.7
# Triangulo: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0) => (4.0, 2.0, 5.0))
# Area: 3.9
Ponto A: (2.0, 3.0, 1.0)
Ponto B: (5.0, 1.0, 4.0)
Ponto C: (4.0, 2.0, 5.0)
Linha: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0)
Comprimento: 4.7
Triangulo: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0) => (4.0, 2.0, 5.0))
Area: 3.9
In [1]:
 
Out[1]: