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()

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()

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()

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

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