A maior rede de estudos do Brasil

Grátis
360 pág.
python para desenvolvedores completo

Pré-visualização | Página 44 de 47

if new_line:
 yield tuple(new_line.split(','))
 except:
 print 'Ocorreu um erro ao ler o arquivo', fn
 raise SystemExit
# Teste
for line in load_csv('teste.csv'):
 print line
Respostas dos exercícios IV 343
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:
# -*- coding: latin1 -*-
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()
2. Crie uma classe derivada de lista com um método retorne os elementos da 
lista sem repetição.
Solução:
# -*- coding: latin1 -*-
344 Respostas dos exercícios IV
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()
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:
# -*- coding: latin1 -*-
class Carro(object):
 """
 Classe que calcula o consumo de um carro.
 """
Respostas dos exercícios IV 345
 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()
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:
# -*- coding: latin1 -*-
import math
class Vetor(object):
346 Respostas dos exercícios IV
 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
Respostas dos exercícios IV 347
print Vetor(4.5, 5, 6) * 5
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:
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):
348 Respostas dos exercícios IV
 
 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
Respostas dos exercícios IV 349
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
350 Respostas dos exercícios V
Respostas dos exercícios V
1. Implementar uma classe Animal com os atributos: nome, espécie, gênero, 
peso, altura e idade. O objeto derivado desta classe deverá salvar seu estado 
em arquivo com um método chamado “salvar” e recarregar o estado em um 
método chamado “desfazer”.
Solução:
# -*- coding: latin1 -*-
import pickle
class Animal(object):
 """
 Classe que representa um animal.
 """
 attrs = ['nome', 'especie', 'genero', 'peso', 'altura', 'idade']
 def __init__(self, **args):
 # Crie os atributos no objeto a partir da lista
 # Os atributos tem None como valor default
 for attr in self.attrs:
 setattr(self, attr, args.get(attr, None))
 
 def __repr__(self):
 dic_attrs = {}
 for attr in self.attrs:
 dic_attrs[attr] = getattr(self, attr)
 return 'Animal: %s' % str(dic_attrs)
 def salvar(self):
 """
 Salva os dados do animal.
 """
 dic_attrs = {}
 for attr in self.attrs:
 dic_attrs[attr] = getattr(self, attr)
 pickle.dump(dic_attrs, file('a.pkl', 'w'))
Respostas dos exercícios V 351
 def desfazer(self):
 """
 Restaura os últimos dados salvos.
 """
 attrs = pickle.load(file('a.pkl'))
 for attr in attrs:
 setattr(self, attr, attrs[attr])
# Teste
gato = Animal(nome='Tinker', especie='Gato', genero='m',
 peso=6, altura=0.30, idade=4)
gato.salvar()
gato.idade = 5
print