Exercícios

Objetivo

Ao final dessa aula você vai saber como escrever um programa em Python utilizando funções e classes. .. , e importar classes usando import. No futuro...

Tópicos

• Exercício com programação orientada a objetos;
• Classe com um objeto como atributo;
• Uso de módulos e import.

Uso de objetos na prática

Para problemas simples, as vantagens do uso de Programação Orientada à Objetos (POO) talvez não fiquem tão claras. Para sistemas complexos, com vários componentes, suas vantagens ficam mais evidentes. Portanto vamos tentar evidenciar essas vantagens com problemas um pouco mais complexos.

Uma vantagem da orientação à objetos é que ela nos permite pensar de forma mais concreta e próxima do comportamento real de componentes de um sistema (ao contrário, por exemplo, de um modelo puramente abstrato).

Uma forma de tratar um problema utilizando objetos é por meio da definição do comportamento dos objetos, antes de implementá-los. Modelar objetos não é uma tarefa simples e, na prática, podem existir vários modelamentos possíveis, cada um com suas vantagens e desvantagens.

Uma forma possível de modelamento é dividir o problema em componentes na forma que você achar mais “natural” (e podem haver várias formas “naturais”!), definindo como cada componente deve se comportar e interagir com os demais componentes, e então criar classes para representar cada componente.

Vamos resolver um exercício mais complexo para ilustrar esse processo.

Exercício Comentado

Vamos pensar por exemplo em como poderíamos resolver o exercício programa Encha de água usando objetos.

Basicamente, o jogo é uma simulação, onde o usuário deve encher um balde com o máximo volume possível de água. A capacidade do balde no entanto é inicialmente desconhecida, e pode variar entre 10 e 50 unidades.

A cada jogada, o jogo sorteia uma quantidade de água, mostra essa quantidade ao usuário e pergunta se o usuário deseja ou não utilizá-la. o jogo (simulação) termina quando o balde estiver cheio ou o usuário desistir de colocar mais água no balde. Para facilitar, o jogo avisa quando o volume armazenado chega ou ultrapassa a metade da capacidade do balde.

Parte A - Modelamento inicial

O programa abaixo descreve, em Python, esse comportamento.

def main(): semente = int(input("Digite a semente para gerar numeros pseudo-aleatorios: ")) jogo = Simulador(semente) fim = False while not fim: jogo.sorteia() opcao = input("Deseja utilizar o volume sorteado? (s/n): ") if opcao == 's': fim = jogo.deposita() # retorna True caso o balde fique cheio else: fim = True jogo.finaliza() class Simulador: def __init__(self, semente): print("construtor do Simulador") def sorteia(self): print("metodo sorteia do Simulador") def deposita(self): print("metodo deposita do Simulador") def finaliza(self): print("metodo finaliza do Simulador") class Balde: def __init__(self): print("metodo construtor de Balde") main()

(comportamento_do_EP1)

Run Save Load

O objetivo dessa primeira parte foi “modelar” o simulador e definir as ações desse objeto. Se essa classe existisse, o nosso programa estaria pronto. Nos parece também que a classe Simulador vai precisar trabalhar com objetos do tipo Balde.

Para chegar nesse programa inicial, como o jogo precisa sortear quantidades de água de forma pseudo-aleatória, “delegamos” as funções para gerenciar esses sorteios a classe Simulador e imaginamos então que a classe precisa receber uma semente ao ser construída. Os demais métodos, deposita() e finaliza(), correspondem às demais ações de um jogo.

Parte B

O próximo passo seria definir a classe Simulador, mas como ela depende de uma outra classe, a Balde, que nos parece mais simples de definir, vamos começar pela definição de Balde.

Para ser utilizado em um jogo, um objeto balde deve precisar dos atributos:

• capacidade : int que indica capacidade máxima do balde
• volume : int volume atual de água no balde
• derramado : água derramada
• cheio : booleano indica se o balde está cheio

Observação

O processo de definição de classes e seus atributos e método é iterativo. Uma vez definido alguns atributos e métodos básicos, a definição de uma classe deve evoluir a medida que as demais classes são definidas. Um outro aspecto que pode ser explorado é criar classes que sejam genéricas, para que possam ser utilizadas em outros problemas. Vamos tentar reutilizar a classe Balde no próximo exercício, e apenas estender a classe Simulador.

Ao criar um Balde, é necessário definir o valor do atributo capacidade, e podemos zerar os atributos volume e derramado.

Ao imprimir um Balde, por exemplo contendo 12 unidades de volume, ele deve corresponder ao texto *12* caso esteja cheio e [12] caso ainda possua volume livre.

A classe deve ter o método deposita(self, v), que recebe uma quantidade de água vol e atualiza o estado do objeto Balde.

def main(): # programa de teste da classe Balde balde = Balde(10) d1 = balde.deposita(3) d2 = balde.deposita(4) print(balde) d3 = balde.deposita(5) print(balde) print(d1, d2, d3) class Balde: def __init__(self, cap): self.capacidade = cap self.volume = 0 self.derramado = 0 self.cheio = False def __str__(self): # remova a linha abaixo e escreva o seu codigo para esse metodo return "__str__ do Balde" def deposita(self, vol): # remova a linha abaixo e escreva o seu codigo para esse metodo print("deposita de Balde", vol) main()

(ex19_1b_tentativa)

Run Save Load

Parte C

Vamos definir agora a classe Simulador. A idea de se criar essa classe é agrupar o estado e operações específicas do simulador (jogo). Vamos incluir também no Simulador todas as operação com random e, para isso, o construtor dessa classe deve receber a semente para o gerador de números pseudo-aleatórios. O construtor deve também inicializar os seguintes atributos:

• balde : objeto Balde
• vol : volume sorteado
• avisou : indica se uma mensagem avisando se o balde atingiu ou passou da metade já foi dada.

Os demais métodos da classe são:

• sorteia(self): que sorteia um volume de água de 1 a 10 unidades atualizando o atributo vol, e imprime esse volume.

• deposita(self): que adiciona o volume vol ao balde. Observe que a função main usa o método deposita do Simulador, mas esse volume deve ser passado do Simulador ao Balde, simplificando as ações necessárias na main.

  O método deposita retorna True se o balde ficar cheio após a operação, e imprime uma mensagem da primeira vez que o volume atingir ou passar da metade da capacidade.

• finaliza(self): imprime as seguintes mensagens:

  • Fim da simulação
  • Capacidade do balde: ___
  • Volume final: ___
  • Balde está (ou não) cheio
  • Volume derramado:

import random # definicao de constantes CAP_MIN = 10 CAP_MAX = 51 # ja ajustado ao random VOL_MIN = 1 VOL_MAX = 11 # ja ajustado ao random def main(): # funcao para teste do simulador sim = Simulador(123) sort = sim.sorteia() # escreva outros testes classe Balde: # copie a sua classe balde class Simulador: def __init__(self, semente): random.seed(semente) capacidade = random.randrange(CAP_MIN, CAP_MAX) self.bal = Balde(capacidade) self.vol = 0 self.avisou = False def sorteia(self): self.vol = random.randrange(VOL_MIN, VOL_MAX) print("Volume sorteado: ", self.vol) return self.vol def deposita(self): # escreva esse metodo abaixo def finaliza(self): # escreva esse metodo abaixo main()

(ex19_1c_tentativa)

Run Save Load

Parte D

Junte as partes anteriores para ter o programa completo. O programa principal (função main) controla a entrada e a saída (usando input e print) com o usuário e o Simulador mantém o estado da simulação e controla o “jogo”.

def main(): print("Vixe, ainda nao fiz essa parte do exercicio!") # copie aqui a definicao das funcoes e classes dos itens A, B e C main()

(aula19_ex191d_tentativa)

Run Save Load

Solução completa.

Exercício 19.2

Usando a mesma classe Balde do Exercício 19.1, modifique a função main e a classe Simulador para implementar o exercício programa Encha de água mais ainda.