NOME: Kailane Saidel

DATA: 16/06/2022

EXERCÍCIO 10

################################################
#1) Classe Bola: Crie uma classe que modele uma bola: Atributos: Cor, circunferência,
#material Métodos: trocaCor e mostraCor.

class Bola:
cor = None
circ = None
material = None
def __init__(self, cor, circ, material):
self.cor = cor
self.circ = circ
self.material = material
def mostracor(self):
return self.cor
def trocacor(self,Ncor):
self.cor=Ncor

B1 = Bola("Branca", 30, "couro")

print(B1.mostracor())
B1.trocacor("azul")
B1.mostracor()

################################################
# 2) Classe Quadrado: Crie uma classe que #modele um quadrado:
# Métodos: Mudar valor do Lado, Retornar valor do Lado e #calcular
Área;

class Quadrado:
Tam = None
area = None

def __init__(self, Tam):

self.Tam = Tam

def mudarTam(self, NTam):

self.Tam = NTam

def retornarTam(self):
return self.Tam

def calculeArea(self):
return (self.Tam * 2)
Q1 = Quadrado(200)
print(Q1.retornarTam())
Q1.mudarTam(100)
print(Q1.retornarTam())
print(Q1.calculeArea())

################################################
#3) Classe Retangulo: Crie uma classe que modele um
#retangulo:
#Atributos: LadoA, LadoB (ou Comprimento e Largura, ou Base #e
Altura, a escolher)
#Métodos: Mudar valor dos lados, Retornar valor dos lados,
#calcular Área e calcular Perímetro;
#Crie um programa que utilize esta classe. Ele deve pedir ao
#usuário que informe as medidades de um local. Depois,
#devecriar um objeto com as medidas e calcular a quantidade
#de pisos e de rodapés necessárias para o local.

class Retangulo:
comprimento = None
largura = None

def __init__(self,comprimento,largura):
self.ladoA = comprimento
self.ladoB = largura

def retornarlados(self):
return self.ladoA, self.ladoB

def mudarlados(self, Ncomprimento, Nlargura):

self.ladoA = Ncomprimento
self.ladoB = Nlargura

def calcularArea(self):
return (self.ladoA * self.ladoB)

def calcularperimetro(self):
return 2 * (self.ladoA + self.ladoB )

####

comp = float(input("Digite o comprimento do local: "))

larg = float(input("Digite a largura do local: "))

local = Retangulo(comp,larg)
print("\nO comprimento e largura do lugar respectivamente é de:
",local.retornarlados())

print("Serão necessários %.2f" % local.calcularArea(),"m2 de

piso.")
print("Serão necessários %.2f" % local.calcularperimetro(),"m2 de
rodapé.")

################################################
# 4) Classe Pessoa: Crie uma classe que modele uma pessoa:
# Atributos: nome, idade, peso e altura
# Métodos: Envelhercer, engordar, emagrecer, crescer.
# Obs: Por padrão, a cada ano que nossa pessoa envelhece,
# sendo a idade dela menor que 21 anos, ela deve crescer 0,5 cm.

class Pessoa:
nome = None
idade = None
peso = None
altura = None
Npeso = None

def __init__(self, nome, idade, peso, altura):

self.nome = nome
self.idade = idade
self.peso = peso
self.altura = altura

def envelhecer(self):
if self.idade < 21:
self.altura += 0.05

self.idade += 1
print("1 Ano depois...")

def engordar(self):
Npeso = float(input("Digite quantos KG a pessoa engordou:
"))
self.peso += Npeso

def emagrecer(self):
Mpeso = float(input("Digite quantos KG a pessoa emagreceu:
"))
self.peso -= Mpeso

def crescer(self):
Naltura = float(input("Digite quantos CM a pessoa cresceu:
"))
 self.altura += (Naltura / 100)

def mostrarpessoa(self):
return print("\nNome:", self.nome, "\nIdade:", self.idade,
"\nPeso:", self.peso, "\nAltura:", "%.2f" % self.altura, "\n")

kailane = Pessoa('Kailane', 19, 45, 1.57)

kailane.mostrarpessoa()
kailane.envelhecer()
kailane.mostrarpessoa()

kailane.engordar()
kailane.mostrarpessoa()

kailane.emagrecer()
kailane.mostrarpessoa()

kailane.crescer()
kailane.mostrarpessoa()

################################################
#5) Classe Conta Corrente: Crie uma classe para implementar uma
conta corrente. A classe deve possuir os seguintes
#atributos: número da conta, nome do correntista e saldo. Os
métodos são os seguintes: alterarNome, depósito e saque;
#No construtor, saldo é opcional, com valor default zero e os
demais atributos são obrigatórios.

class conta_corrente:
numero = None
nome = None
saldo = None

def __init__(self, numero, nome, saldo=0):

self.numero = numero
self.nome = nome
self.saldo = saldo

def alterarNome(self):
Nnome = input("Digite o nome: ")
self.nome = Nnome

def deposito(self):
mais = float(input("Digite o valor que foi depositado: "))
self.saldo += mais

def saque(self):
menos = float(input("Digite o valor que foi sacado: "))
 self.saldo -= menos

def mostrardados(self):
return print("\nCaro(a)",self.nome,", o número da sua conta
é", self.numero, "e o seu saldo atual é de", self.saldo,"reais.")

c1 = conta_corrente(151547,"Bruno")
c1.mostrardados()
c1.deposito()
c1.mostrardados()
c1.saque()
c1.mostrardados()
c1.alterarNome()
c1.mostrardados()

################################################

#6) Classe TV: Faça um programa que simule um televisor criando-o

como um objeto. O usuário deve ser capaz de
#informar o número do canal e aumentar ou diminuir o volume.
Certifique-se de que o número do canal e o nível do volume
#permanecem dentro de faixas válidas.

class TV:

def __init__(self, numCanal=1, volume=20):

self.numCanal = numCanal
self.volume = volume

def aumentarVolume(self):
if self.volume >=0 and self.volume <40:
self.volume = self.volume + 1
print("Vol", self.volume)
else:
print("Vol", self.volume)

def diminuirVolume(self):
if self.volume >0 and self.volume <=40:
self.volume = self.volume - 1
print("Vol",self.volume)
else:
print("Vol", self.volume)

def mudarCanal(self):
print("Você está no canal",self.numCanal)
self.numCanal = int(input("Digite o número do canal que
você deseja ir: "))
while self.numCanal < 1 or self.numCanal >25:
 print("CANAL INVÁLIDO!")
self.numCanal = int(input("\nDigite o número do canal
que você deseja ir: "))
print("Você está no canal", self.numCanal)

#####

TV1 = TV()
TV1.aumentarVolume()
TV1.diminuirVolume()
TV1.mudarCanal()

################################################

#7) Classe Animal de Estimação Virtual: crie uma classe que modele
um Tamagotchi (Bichinho Eletrônico):
#Atributos: Nome, Fome, Saúde e Idade
#Métodos: Alterar Nome, Fome, Saúde e Idade; Retornar Nome, Fome,
Saúde e Idade
#Obs: Existe mais uma informação que devemos levar em
consideração, o Humor do tamagotchi, que é uma combinação
#entre os atributos Fome e Saúde, ou seja, um campo calculado,
então não devemos criar um atributo para armazenar
#esta informação por que ela pode ser calculada a qualquer
momento.

class Bichinho:
nome = None

def __init__(self, nome,idade=0, fome=50, saude=50):

self.nome = nome
self.idade = idade
self.fome = fome
self.saude = saude

def envelhecer(self):
if self.saude > 10:
print("\n1 Ano depois...")
self.idade = self.idade + 1
self.saude = self.saude - 10
else:
print("\nTamagotchi está morrendo, tente medicá-lo!")

def alimentar(self):
if self.fome < 100:
print("\nNhac, nhac...")
self.fome = self.fome + 10
else:
 print("\nEstou cheia(o)!")

def medicar(self):
if self.saude < 100:
print("\n...")
self.saude = self.saude + 10
else:
print("\nEstou saudável!")

def retornaridade(self):
return print(self.nome,"tem",self.idade,"anos.")

def retornarfome(self):
if self.saude > 50:
if self.fome >50:
print("O humor está ótimo")
print("O nível da fome está em", self.fome, "%.")

def retornarsaude(self):
if self.saude > 50:
if self.fome >50:
print("O humor está ótimo")
return print("O nível de saúde está em", self.saude, "%.")

def retornarnome(self):
return print("O nome do seu Tamagotchi é", self.nome)

p1 = Bichinho("Bili")
p1.retornarnome()
p1.retornarsaude()
p1.retornaridade()
p1.retornarfome()
p1.envelhecer()
p1.retornarsaude()
p1.medicar()
p1.alimentar()
p1.retornarsaude()
p1.retornaridade()
p1.retornarfome()

###################

#8) Classe Macaco: Desenvolva uma classe Macaco,que possua os

atributos nome e estomago e pelo menos os métodos
#comer(), verBarriga() e digerir().
#Faça um programa ou teste interativamente, criando pelo menos
dois macacos, alimentando-os com pelo menos 3
#alimentos diferentes e verificando se está alimentado (se tem
barriga) a cada refeição.

class macaco:

def __init__(self, nome):

self.barriga = False
self.nome = nome

def comer(self):
print("\nTABELA: \nB - Banana \nU - Uva \nH - Hambúrguer
\nP - Pizza\n")
comida = input("Digite o que o macaco vai comer: ")

while comida != "B" and comida != "b" and comida != "U" and
comida != "u" and comida != "H" and comida != "h" and comida !=
"P" and comida != "p":
comida = input("Digite o que o macaco vai comer('fim'
para sair): ")
if comida =="fim":
print("\n\t\tSaindo!\n")
break

if comida == "B" or comida == "b":

self.barriga = False
if comida == "U" or comida == "u":
self.barriga = False
if comida == "H" or comida == "h":
self.barriga = True
if comida == "P" or comida == "p":
self.barriga = True

def verbarriga(self):
return print("Barriga:",self.barriga)

def vernome(self):
return print("\nNome:",self.nome)

def digerir(self):
print("Digerindo...")
self.barriga = False

###########

M1 = macaco("Analice")
M1.vernome()
M1.comer()
M1.verbarriga()
M2 = macaco("Oliver")
M2.vernome()
M1.verbarriga()
M1.comer()
M1.verbarriga()
M1.digerir()
M1.verbarriga()

#########################

#13) Classe Funcionário: Implemente a classe Funcionário. Um

empregado tem um nome (um string) e um salário(umdouble). Escreva
um construtor
# com dois parâmetros (nome e salário) e métodos para devolver
nome e salário. Escrevaum pequeno programa que teste sua classe.

class funcionario:
nome = None
salario = None

def __init__(self, nome, salario):

self.nome = nome
self.salario = salario

def getnome(self):
return print (self.nome)

def getsalario(self):
return print (self.salario)

##########

Ana = funcionario("Ana", 1500)

Ana.getnome()
Ana.getsalario()

###################

# 14) Aprimore a classe do exercício anterior para adicionar o

método aumentarSalario (porcentualDeAumento) queaumente o salário
# do funcionário em uma certa porcentagem. Exemplo de uso:
# harry=funcionário("Harry",25000)
# harry.aumentarSalario(10)

class funcionario:
nome = None
salario = None
 def __init__(self, nome, salario):
self.nome = nome
self.salario = salario

def getnome(self):
print("Funcionário(a):")
return self.nome

def getsalario(self):
print("Último salário:")
return self.salario

def aumentarsalario(self, nsalario):

self.salario = self.salario + ((self.salario * nsalario) /
100)

#####

Ana = funcionario("Ana", 1500)

print(Ana.getnome())
print(Ana.getsalario())
Ana.aumentarsalario(50)
print(Ana.getsalario())

######################

#15) Classe Animal de Estimação Virtual++: Melhore o programa do

animal de estimação virtual, permitindo que o usuário especifique
quanto
#de comida ele fornece ao animal e por quanto tempo ele brinca com
o mesmo. Faça com que estes valores afetem quão rapidamente os
níveis
#de fome e tédio caem.

class Bichinho:
nome = None

def __init__(self, nome,idade=0, fome=50, saude=50, humor=50):

self.nome = nome
self.idade = idade
self.fome = fome
self.saude = saude
self.humor = humor

def envelhecer(self):
if self.saude > 10:
print("\n1 Ano depois...")
 self.idade = self.idade + 1
self.saude = self.saude - 10
if self.saude == 10:
print("\nTamagotchi está morrendo, tente medicá-lo!")

if self.humor > 10:

self.humor = self.humor - 10
else:
print("\nTamagotchi está no tédio, tente jogar algo!")

if self.fome >10:
self.fome = self.fome - 10

def alimentar(self):
if self.fome <= 90:
print("\nNhac, nhac...")
self.fome = self.fome + 10
else:
print("\nEstou cheia(o)!")

def medicar(self):
if self.saude <= 90:
print("\n...")
self.saude = self.saude + 10
else:
print("\nEstou saudável!")

def jogar(self):
if self.humor <=90:
self.humor = self.humor + 10
if self.saude >= 50 and self.fome >= 50 and self.humor >=
50:
print("O humor está ótimo")
else:
print("Tédio, vamos jogar mais?")
if self.fome >10:
self.fome = self.fome - 5

def retornaridade(self):
return print(self.nome,"tem",self.idade,"anos.")

def retornarfome(self):
print("O nível da fome está em", self.fome, "%.")

def retornarsaude(self):
return print("O nível de saúde está em", self.saude, "%.")

def retornarnome(self):
 return print("O nome do seu Tamagotchi é", self.nome)

def retornarhumor(self):
return print("O humor do tamagotchi está em: ", self.humor,
"%")

#######

p1 = Bichinho("Bili")
p1.retornarnome()
p1.retornaridade()
p1.retornarfome()
p1.retornarsaude()
p1.retornarhumor()
p1.envelhecer()
p1.alimentar()
p1.medicar()
p1.jogar()
p1.retornaridade()
p1.retornarfome()
p1.retornarsaude()
p1.retornarhumor()