MAB 225 - Computação II - Fabio

Mascarenhas

Lista de Exercícios 2 (14/04/2011)

Para cada uma das classes abaixo lembre de definir um método __init__ apropriado!

1. Crie uma classe que modele uma bola:

Atributos: cor, raio

Métodos: trocaCor e mostraCor, area, volume

import math

class Bola:
def __init__(self, cor, raio):
self.cor = cor
self.raio = raio
def trocaCor(self, cor):
self.cor = cor
def mostraCor(self):
print "Minha cor e %s" % self.cor
def area(self):
return 4 * math.pi * self.raio * self.raio
def volume(self):
return (4 * math.pi * (self.raio ** 3)) / 3

bola = Bola("azul", 2)
bola.mostraCor()
bola.trocaCor("verde")
bola.mostraCor()
print "Area: %f Volume: %f" % (bola.area(), bola.volume())

2. Crie uma classe que modele um quadrado:

Atributos: lado
Métodos: trocaLado, mostraLado, perimetro, area

class Quadrado:
def __init__(self, lado):
self.lado = lado
def trocaLado(self, lado):
:
 self.lado = lado
def mostraLado(self):
print "Meu lado e %s" % self.lado
def perimetro(self):
return 4 * self.lado
def area(self):
return self.lado * self.lado

quad = Quadrado(2)
quad.mostraLado()
quad.trocaLado(3)
quad.mostraLado()
print "Perimetro: %i Area: %i" % (quad.perimetro(), quad.area())

3. Crie uma classe que modele um retangulo:

ladoA, ladoB (ou comprimento e largura, ou base e altura, você escolhe)

Métodos: trocaLados (dois parâmetros), retornaLados (em uma tupla), perimetro, area

class Retangulo:
def __init__(self, ladoA, ladoB):
self.ladoA = ladoA
self.ladoB = ladoB
def trocaLados(self, ladoA, ladoB):
self.ladoA = ladoA
self.ladoB = ladoB
def retornaLados(self):
return (self.ladoA, self.ladoB)
def perimetro(self):
return 2 * self.ladoA + 2 * self.ladoB
def area(self):
return self.ladoA * self.ladoB

ret = Retangulo(2,3)
print "Lados: %i, %i" % ret.retornaLados()
ret.trocaLados(3,4)
print "Lados: %i, %i" % ret.retornaLados()
print "Perimetro: %i Area: %i" % (ret.perimetro(), ret.area())

4. Crie um programa que utilize a classe Retangulo. Ele deve pedir ao usuário (com
input) que informe as medidas de um local. Depois deve pedir a medida do piso
que ele quer usar. O programa então deve calcular quantas unidades do piso o
local vai precisar.

compl = input("Informe o comprimento do local: ")

largl = input("Informe a largura do local: ")
local = Retangulo(compl, largl)
compp = input("Informe o comprimento do piso: ")
:
 largp = input("Informe a largura do piso: ")
piso = Retangulo(compp, largp)
npisos = local.area() * 1.0 / piso.area()
print "Voce vai precisar de %f pisos" % npisos

5. Crie uma classe para modelar uma conta corrente. A classe deve possuir os
atributos numero, correntista e saldo. Os métodos são alterarNome, deposito,
saque e transferencia; No construtor (__init__), saldo é opcional, com valor
default zero e os outros atributos são obrigatórios.

class Conta:
def __init__(self, numero, nome, saldo = 0):
self.numero = numero
self.correntista = nome
self.saldo = saldo
def alterarNome(self, nome):
self.correntista = nome
def deposito(self, valor):
self.saldo = self.saldo + valor
def saque(self, valor):
self.saldo = self.saldo - valor
def transferencia(self, outra, valor):
self.saque(valor)
outra.deposito(valor)

c1 = Conta(123, "Fulano")
c2 = Conta(456, "Beltrano")
c1.deposito(50)
c1.saque(10)
c1.deposito(100)
c1.transferencia(c2, 50)
c2.saque(30)
print "Saldo c1: %i, Saldo c2: %i" % (c1.saldo, c2.saldo)
c1.alterarNome("Fulano de Tal")
print c1.correntista

6. Faça um programa completo que:

Possua uma classe chamada Ponto, com os atributos x e y.

Possua uma classe chamada Retangulo, com os atributos canto1 e canto2, que devem
ser pontos (canto1 é o canto inferior esquerdo, canto 2 o superior direito).
Escreva um método __repr__ para a classe Ponto.
Escreva um método centro para a classe Retangulo que retorne o ponto central do
retângulo (você vai ter que criar um novo ponto).
Pergunte ao usuário as coordenadas de dois pontos, crie os pontos, crie um retângulo
com esses pontos e depois mostre as coordenadas do centro desse retângulo

class Ponto:
def __init__(self, x, y):
:
 self.x = x
self.y = y
def __repr__(self):
return "Ponto(%s, %s)" % (repr(self.x), repr(self.y))

class Retangulo:
def __init__(self, canto1, canto2):
self.canto1 = canto1
self.canto2 = canto2
def centro(self):
x_centro = (self.canto1.x + self.canto2.x) / 2.0
y_centro = (self.canto1.y + self.canto2.y) / 2.0
return Ponto(x_centro, y_centro)

x1 = input("Entre a coordenada x do canto inferior esquerdo: ")

y1 = input("Entre a coordenada y do canto inferior esquerdo: ")
canto1 = Ponto(x1, y1)
x2 = input("Entre a coordenada x do canto superior direito: ")
y2 = input("Entre a coordenada y do canto superior direito: ")
canto2 = Ponto(x2, y2)
ret = Retangulo(canto1, canto2)
print "Ponto central e %s" % repr(ret.centro())

7. Crie uma classe que modele uma bomba de combustível com dois atributos,
capacidade e preco, para a quantidade de combustível na bomba em litros e o
preço por litro do combustível, e os seguintes métodos:

abastecerPorValor: recebe um valor e retorna a quantidade de litros que saiu da

bomba para completar aquele valor (lembre de reduzir a capacidade)
abastecerPorLitro: recebe uma quantidade de litros e retorna quanto custou
(novamente, lembre de reduzir a capacidade)
alterarPreco: muda o preço do combustível na bomba
encherBomba: recebe uma quantidade de litros e adiciona à capacidade da comba

class Bomba:
def __init__(self, capacidade, preco):
self.capacidade = capacidade
self.preco = preco
def abastecerPorValor(self, valor):
litros = valor / self.preco
self.capacidade = self.capacidade - litros
return litros
def abastecerPorLitro(self, litros):
valor = litros * self.preco
self.capacidade = self.capacidade - litros
return valor
def alterarPreco(self, preco):
self.preco = preco
:
 def encherBomba(self, litros):
self.capacidade = self.capacidade + litros

bomba = Bomba(2000, 2.87)

print "Abasteceu %f litros" % bomba.abastecerPorValor(100)
print "Abasteceu %f reais" % bomba.abastecerPorLitro(100)
bomba.alterarPreco(2.55)
print "Abasteceu %f reais" % bomba.abastecerPorLitro(100)
bomba.encherBomba(100)
print "Capacidade: %f litros" % bomba.capacidade

8. Crie uma classe para modelar um número complexo. Defina os métodos especiais
aritméticos para ela (__add__, __sub__, __mul__, __div__), e um método para
retornar o conjugado e o módulo do número complexo.

import math

class Complexo:
def __init__(self, re, im):
self.re = re
self.im = im
def __repr__(self):
return "Complexo(%s, %s)" % (repr(self.re), repr(self.im))
def __add__(self, outro):
return Complexo(self.re + outro.re, self.im + outro.im)
def __sub__(self, outro):
return Complexo(self.re - outro.re, self.im - outro.im)
def __mul__(self, outro):
if isinstance(outro, Complexo):
re = self.re * outro.re - self.im * outro.im
im = self.im * outro.re + self.re * outro.im
return Complexo(re, im)
else:
return Complexo(self.re * outro, self.im * outro)
def norma(self):
return self.re ** 2 + self.im ** 2
def __div__(self, outro):
re = (self.re * outro.re + self.im * outro.im) * 1.0 / outro.norma()
im = (self.im * outro.re - self.re * outro.im) * 1.0 / outro.norma()
return Complexo(re, im)
def conjugado(self):
return Complexo(self.re, -self.im)
def modulo(self):
return math.sqrt(self.norma())

c1 = Complexo(2, 3)
c2 = Complexo(4, 7)
print "c1: %s, c2: %s" % (repr(c1), repr(c2))
:
 print "Soma: %s" % repr(c1 + c2)
print "Sub: %s" % repr(c1 - c2)
print "Mul: %s" % repr(c1 * c2)
print "Mul escalar: %s" % repr(c1 * 3)
print "Div: %s" % repr(c1 / c2)
print "Conjugado c1: %s" % repr(c1.conjugado())
print "Modulo c1: %s" % repr(c1.modulo())
: