def test_retangulo():
retangulo_1 = Retangulo(base=10, altura=12)
assert (retangulo_1.base) == 10
assert (retangulo_1.altura) == 12
assert (retangulo_1.calcular_area()) == 120
assert (retangulo_1.calcular_perimetro()) == 44
def main(instancia):
boxes, Lu, Wu, Hu = get_data(instancia)
container = [Lu, Wu, Hu]
ret = []
for b in boxes:
color_i = np.random.rand(1, 3)
for i in range(b.get('qtd')):
ret.append(Retangulo(b.get('dim'), color=color_i))
now = time()
ret, obj = optimize(ret, container)
obj = get_obj(ret)
print('Time: ' + str(time() - now))
print('Dimensoes: ', Lu, Wu, Hu)
print('Função objetivo: ' + str(obj))
x_lim = max(Lu, Wu, obj)
y_lim = max(Lu, Wu, obj)
z_lim = max(Lu, Wu, obj)
visualiser = PolyVisualiser(
array_polygons=ret,
x_lim=x_lim,
y_lim=y_lim,
z_lim=z_lim,
obj=obj,
alpha=1,
title=instancia,
)
visualiser.animate(no_animation=False)
visualiser.scrol()
visualiser.show()
def cria_retangulos():
x = 45
y = 125
for linha in range(6):
for ret in range(10):
retangulo = Retangulo(x, y, 30, 15)
retangulo.troca_cor()
retangulos.append(retangulo)
x += 31
y += 20
x = 45
def novoJogo(self):
self.player = Retangulo(largura = 100, altura = 20, cor = 'white', pos = (LARGURA//2 + 360, 380), vel = (15, 15), tag = 'player')
self.player.desenhar(self.canvas)
self.canvas.bind('<Motion>', self.move_player)
self.bola = Bola(raio = 30, cor = 'red', pos = (100, 200), vel = (3, 3))
self.r = []
l, c, e = 5, 8, 2
b, h, y0 = 48, 20, 50
for i in range(l):
cor = random.choice(['black', 'orange', 'white', 'lightgray', 'yellow', 'green', 'purple'])
for j in range(c):
r = Retangulo(b, h, cor, (b*j+(j+1)*e, i*h+(i+1)*e + y0), (0, 0), 'rect')
self.r.append(r)
self.canvas.create_text(CANVAS_L/2, CANVAS_A/2, text = 'Bem Vindos!!', fill='white', font='Verdana, 12')
self.jogando = True
def novoJogo(self):
#criação dos elementos do jogo
self.player = Retangulo(largura=100,
altura=20,
cor='white',
pos=(LARGURA // 2 + 360, 380),
vel=(15, 15),
tag='player')
self.player.desenhar(self.canvas)
#movendo o player com o mouse
self.canvas.bind('<Motion>', self.move_player)
#criar a bolinha do jogo
self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(3, 3))
#lista dos retangulos
self.r = []
l, c, e = 5, 8, 2 #linhas, colunas e espaçacamentos
b, h, y0 = 48, 20, 50 #base, altura e posição inicial
for i in range(l):
cor = random.choice([
'black', 'orange', 'white', 'lightgray', 'yellow', 'green',
'purple'
])
for j in range(c):
r = Retangulo(b, h, cor,
(b * j + (j + 1) * e, i * h + (i + 1) * e + y0),
(0, 0), 'rect')
self.r.append(r)
self.canvas.create_text(CANVAS_L / 2,
CANVAS_A / 2,
text='Bem Vindos!',
fill='white',
font='Verdana, 12')
#mudar o estado para jogando
self.jogando = True
def novoJogo(self):
"""
Cria os elementos necessário para um novo jogo
"""
#Criamos a bola que irá se movimentar
self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(3, 3))
#E o player tambem
self.player = Retangulo(largura=100,
altura=20,
cor='green',
pos=(LARGURA // 2 + 100, 350),
vel=(15, 15),
tag='player')
self.player.desenhar(self.canvas)
#E adicionamos o evento de movimentação com o uso do teclado para o player
self.canvas.bind('<Motion>', self.move_player)
#Lista dos retângulos
self.r = []
#E por fim as diversas fileiras de retângulos
l, c, e = 5, 8, 2 #linhas, colunas e espaçamento
b, h, y0 = 48, 20, 50 #Base, altura e posição inicial dos retângulos
for i in range(l):
cor = random.choice(
['green', 'orange', 'white', 'lightgray', 'yellow', 'purple'])
for j in range(c):
r = Retangulo(b, h, cor,
(b * j + (j + 1) * e, i * h + (i + 1) * e + y0),
(0, 0), 'rect')
self.r.append(r)
#Mantemos uma variável para mostrar que ainda está rolando um jogo
self.jogando = True
def novoJogo(self):
"""
Cria os elementos de um novo jogo
"""
#criar a bola q irá se movimentar
self.bola = Bola(raio=30, cor='red', pos=(100, 200), vel=(3, 3))
#criar player tbm
self.player = Retangulo(largura=100,
altura=20,
cor='green',
pos=(LARGURA // 2 + 100, 350),
vel=(15, 15),
tag='player')
#self.player = self.canvas.create_rectangle((CANVAS_L//2, 350), (CANVAS_L//2 + 100, 370), fill = 'green', tag='player')
self.player.desenhar(self.canvas)
#adicionar o evento de movimentação com o uso do teclado
self.canvas.bind('<Motion>', self.move_player)
#criar arco dentro da bola
#self.canvas.create_arc(p[0], p[1], p[0] + raio, p[1] + raio, fill='orange', start=60, extent = 90, tag='bola')
#Lista dos retângulos
self.r = []
#E por fim as diversas fileiras de retângulos
l, c, e = 5, 8, 2 #linhas, colunas e espaçamento
b, h, y0 = 48, 20, 50 #Base, altura e posição inicial dos retângulos
for i in range(l):
cor = random.choice(
['green', 'orange', 'white', 'lightgray', 'yellow', 'purple'])
for j in range(c):
r = self.canvas.create_rectangle(b * j + (j + 1) * e,
i * h + (i + 1) * e + y0,
b * j + (j + 1) * e + b,
i * h + (i + 1) * e + y0 + h,
fill=cor,
tag='rect')
self.r.append(r)
#self.canvas.create_text(CANVAS_L/2, CANVAS_A/2, text = 'OLA COLEGA!', fill = 'white')
#cria bola do jogo
self.jogando = True
def retanguloperi(): #definindo a função
print("Voce escolheu o Perimetro do Retangulo.") #Situando o usuário
try: # utilizamos o try para tratar teclas que não sejam numéricas com excessão do ponto para valores flutuantes
base = float(input("Digite a base do retangulo: ")
) #recebendo os valores e setando nas variaveis
altura = float(input("Digite a altura do retangulo: "))
meuRetangulo = Retangulo(
base, altura) #instanciando a classe e passando os parametros
meuperi = meuRetangulo.calculaPerimetroreta(
) # #chamando a classe para receber o resultado
print("\nO perimetro do retangulo é {:.2f} cm".format(
meuperi)) # apresentando a area do circulo para o usuario
escolha() # chamando a função novamente
except ValueError: # excessão do try, valor recebido errado, que não seja número
print(
"Opção inválida, Não utilize letras, virgula ou deixe vazio!\nA entrada deve ser primeiro um número seguido ou não de ponto!"
"\nPor Favor, tente novamente."
) # utilizando barra invertida e n quebramos linha
escolha() # chamando a função novamente
from retangulo import Retangulo
r1 = Retangulo(5, 6)
print("Área do retangulo: ", r1.calcularArea())
from retangulo import Retangulo
#receber do usuarios as medidas
lado_a = int(input("Informe a medida do lado A do local:"))
lado_b = int(input("Informe a medida do lado B do local:"))
lado_a_piso = int(input("Informe a medida do lado A do piso:"))
lado_b_piso = int(input("Informe a medida do lado B do piso:"))
sala = Retangulo(lado_a, lado_b)
piso = Retangulo(lado_a_piso, lado_b_piso)
sala.retornar_vlr_lado()
area_sala = sala.calculo_area()
area_piso = piso.calculo_area()
perimetro_sala = sala.calculo_perimetro()
piso.calculo_perimetro()
qtd_pisos = (area_sala / area_piso)
print("A qtd de pisos necessarios é:", qtd_pisos)
qtd_rodape = (perimetro_sala / lado_a_piso)
print("A qtd de rodape necessarios é:", qtd_rodape)
def main():
figuraComplexa = FiguraComplexa(Quadrado(3), Quadrado(10), Retangulo(2, 7),
Retangulo(5, 3))
print(figuraComplexa)
def setUp(self):
self.retangulo = Retangulo(3, 5)
import pygame
from bola import Bola
from retangulo import Retangulo
bola = Bola()
retangulo = Retangulo(0, 0, 0, 0)
largura_tela = 400
altura_tela = 400
screen_wh = largura_tela, altura_tela
velocidade_x = 5
velocidade_y = 5
BLACK = (0, 0, 0)
relogio = pygame.time.Clock()
retangulos = []
def cria_bola():
pos_x = 200
pos_y = 380
raio = 20
bola.set_centro_x(pos_x)
bola.set_centro_y(pos_y)
bola.set_raio(raio)
def main():
quadrado = Quadrado(5)
retangulo = Retangulo(5,10)
circunferencia = Circunferencia(10)
print(circunferencia.calcularArea(), retangulo.calcularArea(), quadrado.calcularArea())
from retangulo import Retangulo
comprimento = float(input("Digite o valor do comprimento do local: "))
largura = float(input("Digite o valor da largura do local: "))
piso = Retangulo()
lag_piso = float(input("Digite a largura do piso "))
com_piso = float(input("Digite o comprimento do piso "))
piso.mudar_valores(lag_piso, com_piso)
area_total = largura * comprimento
num_pisos = area_total / piso.calcula_area()
print(num_pisos)
pygame.init()
fundo = pygame.display.set_mode((400, 400))
pygame.display.set_caption('Retangulo')
preto = (0, 0, 0)
branco = (255, 255, 255)
azul = (0, 0, 255)
verde = (0, 255, 0)
vermelho = (255, 0, 0)
cor1 = (220, 50, 50)
cor2 = (100, 100, 0)
cor3 = (50, 100, 150)
cor4 = (255, 200, 0)
#def __init__(self, posX, posY, largura, altura, cor):
a1 = Retangulo(10, 10, 10, 10, vermelho)
a2 = Retangulo(35, 10, 10, 10, branco)
a3 = Retangulo(60, 10, 10, 10, azul)
a4 = Retangulo(85, 10, 10, 10, verde)
a5 = Retangulo(110, 10, 10, 10, cor1)
a6 = Retangulo(135, 10, 10, 10, cor2)
a7 = Retangulo(135, 10, 10, 10, cor3)
a8 = Retangulo(160, 10, 10, 10, cor4)
a9 = Retangulo(185, 10, 10, 10, verde)
a10 = Retangulo(210, 10, 10, 10, branco)
b1 = Retangulo(10, 35, 10, 10, vermelho)
b2 = Retangulo(35, 35, 10, 10, branco)
b3 = Retangulo(60, 35, 10, 10, azul)
b4 = Retangulo(85, 35, 10, 10, verde)
b5 = Retangulo(110, 35, 10, 10, cor1)
def main(instance):
print("Server: " + str(platform.node()) + "\n")
# Obtem os valores do arquivo e cria os retângulos
# filename = 'problema1.data'
filename = instance
boxes, Lu, Wu, Hu = get_data(filename)
filename = filename.replace('.data', '', 1)
filename = filename.replace('instances/', '', 1)
print(filename)
# Cria os conjuntos X,Y,Z
BigX, BigY, BigZ = [], [], []
for i in boxes: # Percorrer cada tipo de caixa
p, q, r = 0, 0, 0
for e in range(1, i.get('qtd') + 1):
l = i.get('dim')[0]
p += e * l
for e in range(1, i.get('qtd') + 1):
l = i.get('dim')[1]
q += e * l
for e in range(1, i.get('qtd') + 1):
l = i.get('dim')[2]
r += e * l
BigX.append(p)
BigY.append(q)
BigZ.append(r)
container = [Lu, Wu, Hu]
BigX = [i for i in range(sum(BigX))]
BigY = [i for i in range(sum(BigY))]
BigZ = [i for i in range(sum(BigZ))]
# print(BigX, BigY, BigZ, sep='\n')
m = Model("3D-ODRPP")
m.setParam('TimeLimit', 1 * 3600.0)
L = m.addVar(vtype=GRB.CONTINUOUS, name="L", lb=0, ub=GRB.INFINITY)
W = m.addVar(vtype=GRB.CONTINUOUS, name="W", lb=0, ub=GRB.INFINITY)
H = m.addVar(vtype=GRB.CONTINUOUS, name="H", lb=0, ub=GRB.INFINITY)
z_obj = m.addVar(vtype=GRB.CONTINUOUS, name="Z", lb=0, ub=GRB.INFINITY)
m.addConstr(z_obj == L + W + H, "z_objective")
m.setObjective(z_obj, GRB.MINIMIZE)
X, Y, Z = [], [], []
for i, box in enumerate(boxes, start=0):
li = box.get('dim')[0]
wi = box.get('dim')[1]
hi = box.get('dim')[2]
X_i = [p for p in range(0, Lu - li)]
Y_i = [p for p in range(0, Wu - wi)]
Z_i = [p for p in range(0, Hu - hi)]
X.append(X_i)
Y.append(Y_i)
Z.append(Z_i)
# print(X, Y, Z, sep='\n')
# Criação das variáveis binárias
x_bin = []
for i, box in enumerate(boxes):
rotations = list(permutations(box.get('dim')))
# print(box.get('dim'), rotations, sep='\t')
k_list = []
for k, b in enumerate(rotations):
p_list = []
for p in X[i]:
q_list = []
for q in Y[i]:
r_list = []
for r in Z[i]:
index = '[' + str(i) + '][' + str(k) + '][' + str(
p) + '][' + str(q) + '][' + str(r) + ']'
x = m.addVar(vtype=GRB.BINARY, name='X_' + index)
r_list.append(x)
q_list.append(r_list)
p_list.append(q_list)
k_list.append(p_list)
x_bin.append(k_list)
print(' = Variables Added')
# Constraint 2
for s in BigX:
for t in BigY:
for u in BigZ:
soma_r2 = LinExpr()
for i, box in enumerate(boxes, start=0):
rotations = list(permutations(box.get('dim')))
for k, b in enumerate(rotations):
li, wi, hi = b[0], b[1], b[2]
for p in X[i]:
for q in Y[i]:
for r in Z[i]:
if s - li + 1 <= p <= s:
if t - wi + 1 <= q <= t:
if u - hi + 1 <= r <= u:
soma_r2 += x_bin[i][k][p][q][r]
# index = str(i)
index = '[' + str(s) + '][' + str(t) + '][' + str(u) + ']'
m.addConstr(soma_r2 <= 1, name='Restricao2_' + index)
print(' = Constraint 2 adicionada')
# Constraint 3
for j, box in enumerate(boxes, start=0):
bj = box.get('qtd')
soma_r3 = LinExpr()
rotations = list(permutations(box.get('dim')))
for k, b in enumerate(rotations):
for p in X[j]:
for q in Y[j]:
for r in Z[j]:
soma_r3 += x_bin[j][k][p][q][r]
m.addConstr(soma_r3 == bj, name='Restricao3_' + str(j))
print(' = Constraint 3 adicionada')
# Restrições 4, 5 e 6
for i, box in enumerate(boxes, start=0):
rotations = list(permutations(box.get('dim')))
for k, b in enumerate(rotations):
for p in X[i]:
for q in Y[i]:
for r in Z[i]:
index = '[' + str(i) + '][' + str(k) + '][' + str(
p) + '][' + str(q) + '][' + str(r) + ']'
li, wi, hi = b[0], b[1], b[2]
algo_p = (p + li) * x_bin[i][k][p][q][r]
algo_q = (q + wi) * x_bin[i][k][p][q][r]
algo_r = (r + hi) * x_bin[i][k][p][q][r]
m.addConstr(algo_p <= L, name='Restricao4_' + index)
m.addConstr(algo_q <= W, name='Restricao5_' + index)
m.addConstr(algo_r <= H, name='Restricao6_' + index)
print(' = Restrições 4,5,6 adicionadas')
m.write('models/modelo_' + filename + '.lp')
print(' = Model written!')
m.optimize()
if m.status == GRB.Status.OPTIMAL:
m.write('results/resultado_' + filename + '.sol')
print('Container: ', Lu, Wu, Hu, sep='\t')
print('\nFunção objetivo: ',
str(round(L.X)),
str(round(W.X)),
str(round(W.X)),
sep='\t')
# Recupera as posições das caixas
solutions = []
for i, box in enumerate(boxes, start=0):
sol_box = []
for k in range(6):
for p in X[i]:
for q in Y[i]:
for r in Z[i]:
if x_bin[i][k][p][q][r].X == 1:
sol_box.append([i, (p, q, r), k])
solutions.append(sol_box)
# solutions = [[[0, (3, 0, 0), 0], [0, (4, 0, 0), 0]], [[1, (0, 0, 0), 1], [1, (0, 3, 0), 1]],
# [[2, (1, 0, 4), 2], [2, (2, 0, 4), 4]], [[3, (1, 1, 5), 1], [3, (2, 2, 5), 4], [3, (1, 3, 5), 5]]]
ret = []
for i, box in enumerate(boxes):
color_b = np.random.rand(1, 3)
rotated_box = list(permutations(box.get('dim')))
for j in range(box.get('qtd')):
sol = solutions[i][j]
r = rotated_box[sol[2]]
r = Retangulo(vertex=r, color=color_b)
r.change_vertex(list(sol[1]))
ret.append(r)
ret.sort(key=lambda x: max(x.vertex[2]), reverse=True)
file_write_list = open('results/retangulos_' + filename + '.bin', 'wb')
pickle.dump(ret, file_write_list)
# Arquivo principal do programa.
from circulo import Circulo # Do arquivo circulo importe a classe Circulo
from retangulo import Retangulo # Do arq retangulo importa a classe Retangulo
print("Escolha qual forma deseja utilizar nos calculos!")
forma = int(input("1-Circulo\n2-Retangulo\n->"))
if forma == 1: # Se foi escolhido a forma 1 (Circulo)
raio = float(input("Quantos centimetros tem o raio: ")) # Entrada de dados
meuCirculo = Circulo(raio) # Na variavel meuCirculo cria um novo
# objeto do tipo Circulo, passando raio como parâmetro
meuCirculo.calc_area() # Chama o método calc_area
print("A área do circulo é %5.2fcm²!" % meuCirculo.area)
meuCirculo.calc_perimetro() # Chama o método calc_perimetro
print("O perímetro do circulo é %5.2fcm!" % meuCirculo.perimetro)
elif forma == 2:
altura = int(input("Digite a medida da altura do retangulo: ")) # Entrada de dados
largura = int(input("Digite a medida da largura do retangulo: "))
meuRetangulo = Retangulo(altura, largura) # Na variavel meuretangulo cria um novo
# objeto do tipo Retangulo, passando ladoMaior e ladoMenor como parâmetros
meuRetangulo.calc_area() # Chama o método calc_area
print("A área do retangulo é %5.2fcm²!" % meuRetangulo.area)
meuRetangulo.calc_perimetro() # Chama o método calc_perimetro
print("O perímetro do retangulo é %5.2fcm!" % meuRetangulo.perimetro)
else:
print("Opição inválida...")
def given_um_retangulo(context, x, y, w, h):
"""Cria objeto retangulo com os parametros especificados."""
context.retangulo = Retangulo(x, y, w, h)
# EXERCÍCIO 09 - LISTA 08 - CLASSES
print('Classe Ponto e Retângulo')
print('########################')
print()
from ponto import Ponto
from retangulo import Retangulo
X = float(input('Insira a Coordenada X: '))
Y = float(input('Insira a Coordenada Y: '))
altura = float(input('Insira a altura do Retângulo: '))
largura = float(input('Insira a largura do Retângulo: '))
coordenadas = Ponto(X,Y)
retangulo = Retangulo(altura,largura)
centro_retanguloX = retangulo.crX()+coordenadas.X()
centro_retanguloY = retangulo.crY()+coordenadas.Y()
print('A coordenada X do centro do retângulo é: ',centro_retanguloX)
print('A coordenada Y do centro do retângulo é: ',centro_retanguloY)
def main(instance, model_file):
print("Server: " + str(platform.node()) + "\n")
# Obtem os valores do arquivo e cria os retângulos
filename = instance
boxes, Lu, Wu, Hu = get_data(filename)
filename = filename.replace('.data', '', 1)
filename = filename.replace('instances/', '', 1)
print(filename)
m = read(model_file)
print('Problema: ' + m.getAttr('modelName'))
m.setParam('TimeLimit', 1 * 3600.0)
vars = m.getVars()
z_obj, L, W, H = vars[0], vars[1], vars[2], vars[3]
X, Y, Z = [], [], []
for i, box in enumerate(boxes, start=0):
li = box.get('dim')[0]
wi = box.get('dim')[1]
hi = box.get('dim')[2]
X_i = [p for p in range(0, Lu - li)]
Y_i = [p for p in range(0, Wu - wi)]
Z_i = [p for p in range(0, Hu - hi)]
X.append(X_i)
Y.append(Y_i)
Z.append(Z_i)
m.optimize()
# Recuperar as variáveis binárias
x_bin = []
for i, box in enumerate(boxes):
rotations = list(permutations(box.get('dim')))
k_list = []
for k, b in enumerate(rotations):
p_list = []
for p in X[i]:
q_list = []
for q in Y[i]:
r_list = []
for r in Z[i]:
index = 'X_' + '{}_{}_{}_{}_{}'.format(i, k, p, q, r)
x = m.getVarByName(index)
r_list.append(x)
q_list.append(r_list)
p_list.append(q_list)
k_list.append(p_list)
x_bin.append(k_list)
print(' = Variables Added')
if True:
m.write('results/resultado_' + filename + '.sol')
print('Container: ', Lu, Wu, Hu, sep='\t')
container = [Lu, Wu, z_obj.X]
print('\nFunção objetivo: ',
container[0],
container[1],
container[2],
sep='\t')
# Recupera as posições das caixas
solutions = []
for i, box in enumerate(boxes, start=0):
sol_box = []
for k in range(6):
for p in X[i]:
for q in Y[i]:
for r in Z[i]:
if x_bin[i][k][p][q][r].X == 1:
sol_box.append([i, (p, q, r), k])
solutions.append(sol_box)
ret = []
for i, box in enumerate(boxes):
color_b = np.random.rand(1, 3)
rotated_box = list(permutations(box.get('dim')))
for j in range(box.get('qtd')):
sol = solutions[i][j]
r = rotated_box[sol[2]]
r = Retangulo(vertex=r, color=color_b)
r.change_vertex(list(sol[1]))
ret.append(r)
ret.sort(key=lambda x: max(x.vertex[2]), reverse=True)
file_write_list = open('results/retangulos_' + filename + '.bin', 'wb')
pickle.dump(ret, file_write_list)
visualiser = PolyVisualiser(
array_polygons=ret,
x_lim=container[0],
y_lim=container[1],
z_lim=container[2],
obj=container[2],
alpha=.8,
title=filename,
)
visualiser.animate(no_animation=False)
visualiser.scrol()
visualiser.show()
from retangulo import Retangulo retanguo1 = Retangulo(8, 5) retanguo1.imprimir_valores() retanguo1.imprimir_area()
# ----Quadrado------------------
print(' Configuração para a Quadrado!')
vquadrado = Quadrado()
vquadrado.tamanho_lado = int(input('Digite o lado para o quadrado: '))
vquadrado.trocaLado(vquadrado.tamanho_lado)
vquadrado.mostraInfoQuadrado()
print('''
Quadrado configurado!
''')
# -----Retangulo----------------
print(' Configuração para Retangulo!')
vretangulo = Retangulo()
vretangulo.lado_a = int(input('Informe o lado A: '))
vretangulo.lado_b = int(input('Informe o lado B: '))
vretangulo.setaLados(vretangulo.lado_a, vretangulo.lado_b)
vretangulo.mostraInfoRetangulo()
print('''
Retangulo configurado!
''')
def escolha():
forma = input(
"1 - Circulo\n2 - Retangulo\n3 - Triangulo\n4 - Trapézio\n5 - Sair\n-->"
) # menu de opções
try: # utilizamos o try para tratar teclas que não sejam numéricas com excessão do ponto para valores flutuantes
if forma == "1":
raio = float(input("Quantos centimetros tem o raio:"))
meuCirculo = Circulo(raio) # instaciando a classe
minhaarea = meuCirculo.calcularAreacirc(
) # recebendo a area da classe circulo
meuperimetro = meuCirculo.calculaPerimetrocirc(
) # recebendo o perimetro da classe circulo
print("\nA area do círculo é {:.2f} cm".format(minhaarea))
print("\nO Perimetro do Círculo é {:.2f} cm ".format(meuperimetro))
elif forma == "2":
base = float(input("Digite a base do retangulo: ")
) # recebndo os valores e setando nas variaveis
altura = float(input("Digite a altura do retangulo: "))
meuRetangulo = Retangulo(
base, altura
) # instanciando a minha classe e enviando meus parametros
areareta = meuRetangulo.calcularAreareta(
) # chamando a classe para receber o resultado
meuperi = meuRetangulo.calculaPerimetroreta(
) # #chamando a classe para receber o resultado
print("\nA area do retangulo é {:.2f} cm²".format(
areareta)) # apresentando a area do circulo para o usuario
print("\nO perimetro do retangulo é {:.2f} cm".format(
meuperi)) # apresentando a area do circulo para o usuario
elif forma == "3":
lado1 = float(input("Digite o lado 1 do triangulo: ")
) # recebndo os valores e setando nas variaveis
lado2 = float(input("Digite o laodo 2 do triangulo: "))
base = float(input("Digite a base do triangulo: ")
) # recebndo os valores e setando nas variaveis
altura = float(input("Digite a altura do triangulo: "))
meuTriangulo = Triangulo(
lado1, lado2, base, altura
) # instanciando a minha classe e enviando meus parametros
areatri = meuTriangulo.calcularAreaTri(
) # chamando a classe para receber o resultado
peritri = meuTriangulo.calculaPerimetroTri(
) # #chamando a classe para receber o resultado
print("\nA area do triangulo é {:.2f} cm²".format(
areatri)) # apresentando a area do circulo para o usuario
print("\nO perimetro do triangolo é {:.2f} cm".format(
peritri)) # apresentando a area do circulo para o usuario
elif forma == "4":
lado1 = float(input("Digite o lado 1 do trapezio: ")
) # recebndo os valores e setando nas variaveis
lado2 = float(input("Digite o laodo 2 do trapezio: "))
basemenor = float(input("Digite a base Menor do trapezio: ")
) # recebndo os valores e setando nas variaveis
basemaior = float(input("Digite a base Maior do trapezio: ")
) # recebndo os valores e setando nas variaveis
altura = float(input("Digite a altura do trapezio: "))
meuTrapezio = Trapezio(
lado1, lado2, basemenor, basemaior, altura
) # instanciando a minha classe e enviando meus parametros
areatrap = meuTrapezio.calcularAreaTrap(
) # chamando a classe para receber o resultado
peritrap = meuTrapezio.calculaPerimetroTrap(
) # #chamando a classe para receber o resultado
print("\nA area do trapezio é {:.2f} cm²".format(
areatrap)) # apresentando a area do circulo para o usuario
print("\nO perimetro do trapezio é {:.2f} cm".format(
peritrap)) # apresentando a area do circulo para o usuario
elif forma == "5":
print("ATÉ A PRÓXIMA!!!") # despedida
exit() #finaliza o programa
else:
print(
"Opção inválida, a escolha deve ser uma operação da lista!\nPor Favor, tente novamente."
) # caso usuário digite tecla que não faz parte das opções
escolha() # chamada da função para reinicialização do programa
except ValueError: # excessão do try, valor recebido errado, que não seja número
print(
"Opção inválida, Não utilize letras, virgula ou deixe vazio!\nA entrada deve ser primeiro um número seguido ou não de ponto!\nPor Favor, tente novamente."
)
escolha() # chamada da função para reinicialização do programa
