__STR__ Python 🐍 Programación Orientada a Objetos # 033

[@SergioACGiraldo]

Curso Completo ➢ bit.ly/CAE_Python
Lista de POO ➢ bit.ly/POO_CAE
🐍 Lee la info en la web 💻 ➢ bit.ly/3v8onk6
Tutorial de Matlab Español ➢ bit.ly/2Fks7XN
Curso de Simulink desde Cero ➢ bit.ly/3eSSOAC

[@yr9413]

class Rectangulo:
"""
Clase para el cálculo de propiedades del Rectangulo
"""
#Método constructor:
def __init__(self,largo, ancho, altura):
self.largo=largo
self.ancho=ancho
self.altura=altura

#Método mágico; STR:
def __str__(self): #mostramos la impresion a traves de este metodo
return (f' largo:{self.largo}
ancho:{self.ancho}
altura:{self.altura}')

#Métodos de instancia:
def perimetro(self):
return (2*self.largo) + (2*self.ancho)

def area (self):
return self.largo*self.ancho

def volumen(self):
return self.largo*self.ancho*self.altura
if __name__=='__main__':
rectangulo1=Rectangulo(6, 8, 4)
print(f'El rectangulo 1 posee:
{rectangulo1}')

[@macasanovat]

class PiramideC():

'''Cálculos de una pirámide de base cuadrada perímertro, área y volumen'''

# Constructor

def __init__(self, lado, altura, apotema):
self.lado = lado
self.altura = altura
self.apotema = apotema
# Método de cálculo del perímetro
def perimetro(self):
return 4 * self.lado
# Método de cálculo del área
def area(self):
return 2 * self.lado * (self.lado + 2 * self.apotema)
# Método de cálculo del área lateral
def areaLateral(self):
return 2 * self.lado * self.apotema
# Método de cálculo del área total
def areaTotal(self):
return self.area() + self.lado ** 2
# Método de cálculo del volumen
def volumen(self):
return (self.lado ** 2) * self.altura / 3

def __str__(self):
return (f'
Lado: {self.lado}
altura: {self.altura}
apotema: {self.apotema}')
if __name__ == '__main__':
piramide1 = PiramideC(6, 4, 5)
print(f'La piramide1 es: {piramide1}', '
')
print(f'El perímetro de la pirámide cuadrangular es {round(piramide1.perimetro(),2)}m2', '
')
print(f'El área de la pirámide cuadrangular es {round(piramide1.area(),2)}m2')
print(f'El área lateral de la pirámide cuadrangular es {round(piramide1.areaLateral(),2)}m2')
print(f'El área total de la pirámide cuadrangular es {round(piramide1.areaTotal(),2)}m2', '
')
print(f'El volumen de la pirámide cuadrangular es {round(piramide1.volumen(),2)}m3')

[@reinelsisnett2930]

"""
Reto: Creaciòn de la clase Cono y la funcion __str__ .
"""
from math import pi
class Cono:

# Método constructor
def __init__(self, height = 1, radius = 1, volumen = 1):
#self.hipotenusa = hipotenusa
self.height = height
self.radius = radius
self.volumen = volumen


# Método de instancia para calcular el volumen de un cono
def vol(self):
return (pi*radius**2)*height / 3

# Método de instancia para calcular el radio de un cono
def radio(self):

return ((3*volumen)/(pi*height))**.5

#Método de instancia para calcular la altura de un cono
def altura(self):

return ((3*volumen)/(pi*radius**2))
# Metodo de instancia para imprimir los datos del Cono
def __str__(self):
return (f'Datos del Cono:
Radio: {radius}
Volumen: { volumen}
Altura: {height} ')
if __name__ == '__main__':
cono_1 = Cono()
print("Caso 1: Para determinar el volumen de un cono es necesario conocer el radio y la altura:")
radius = float(input("Radio: "))
height = float(input("Altura: "))
volumen = cono_1.vol()
print(f'El volumen del cono es {cono_1.vol()}')
print("Caso 2: Para determinar el radio, conociendo el volumen anterior, introduzca la altura")
height = float(input("Altura: "))
print(f'El radio del cono es {cono_1.radio()}')
print("Caso 3: Para determinar la altura, conociendo el radio, introduzca el volumen")
volumen = float(input("Volumen: "))
print(f'La altura del cono es {cono_1.altura()}')

print(cono_1)
Caso 1: Para determinar el volumen de un cono es necesario conocer el radio y la altura:
Radio: 5
Altura: 10
El volumen del cono es 261.79938779914943
Caso 2: Para determinar el radio, conociendo el volumen anterior, introduzca la altura
Altura: 10
El radio del cono es 5.0
Caso 3: Para determinar la altura, conociendo el radio, introduzca el volumen
Volumen: 261.79
La altura del cono es 9.999641412486548
Datos del Cono:
Radio: 5.0
Volumen: 261.79
Altura: 10.0

[@gustavofossati7184]

Hola Sergio, comparto el reto5
from math import sqrt
class Triangulos_rectangulos:
"""
clases de triángulos
"""
def __init__(self, base, altura, color):
self.base = base
self.altura = altura
self.color = color
def area(self, base, altura):
return base * altura/2

def perimetro(self, base, altura):
hipo = sqrt( base**2+ altura**2)
return base + altura + hipo

def __str__(self):
return (f'Base: {self.base}
Altura: {self.altura}
Color : {self.color}')

if __name__ == '__main__':
triangulo1 = Triangulos_rectangulos(3,4,'rojo')
print(triangulo1.perimetro(3,4))
print(triangulo1.area(3,4))
print(triangulo1.color)
triangulo2 = Triangulos_rectangulos(5,6,'azul')
print(triangulo2.perimetro(5,6))
print(triangulo2.area(5,6))
print(triangulo2.color)
print(triangulo1.__dict__)
print(triangulo1.__doc__)
print(dir(triangulo1))
print(f'El primer triángulo instanciado tiene :
{triangulo1}')
print(f'El segundo triángulo instanciado tiene :
{triangulo2}')

[@axel_meza]

from math import sqrt
'''
Creamos una clase Dodecaedro que tiene un constructor con el parámetro de la arista del dodecaedro.
Después, creamos dos métodos: uno para calcular el área superficial del dodecaedro y otro para calcular su volumen.
Aclaración: Se trata de un dodecaedro regular.
'''
class Dodecaedro:

def __init__(self, arista):
self.arista = arista
# Método de instancia para calcular el área superficial del dodecaedro regular
def area_superficial(self):
return 3 * (sqrt(25 + 10 * sqrt(5))) * self.arista ** 2

# Método de instancia para calcular el volumen del dodecaedro regular
def volumen(self):
return ((15 + 7 * sqrt(5)) / 4) * self.arista ** 3

def __str__(self):
return f'{self.arista}'

if __name__ == '__main__':
# Creamos el primer objeto
dodecaedro1 = Dodecaedro(5)
print(f'La arista del dodecaedro es de: {dodecaedro1}')
print(f'El área superficial del dodecaedro es: {dodecaedro1.area_superficial():.2f}')
print(f'El volumen del dodecaedro es: {dodecaedro1.volumen():.2f}')
'''
La arista del dodecaedro es de: 5
El área superficial del dodecaedro es: 516.14
El volumen del dodecaedro es: 957.89
'''

[@mikelrojo8330]

Mi programa:
from math import pi, sqrt
class Cono:

#Método constructor
def __init__(self, radio, altura, color, rayas = False):
self.radio = radio
self.altura = altura
self.color = color
self.rayas = rayas

#Método de instancia (método mágico)
def __str__(self):
if cono1.rayas == True:
rayado = "Sí"
else:
rayado = 'No'
return (f'Radio: {self.radio}
Altura: {self.altura}
Color: {self.color}
Rayas: {rayado}')
#Método de instancia
def area_base(self, radio):
return pi * self.radio**2

#Método de instancia
def superficie_lateral(self, radio, altura):
return pi * self.radio * sqrt(self.radio **2 + self.altura **2)

#Método de instancia
def volumen(self, radio, altura):
return (self.altura / 3) * pi * self.radio**2

#Método de instancia
def color1(self):
return self.color
#Entry point
if __name__ == '__main__':
cono1 = Cono(4.5, 7.8, 'Verde', False)
print(f'El cono 1 tiene:
{cono1}')
print(f'El cono tiene una base de {round(cono1.area_base(cono1.radio), 2)}cm²')
print(f'El cono tiene una superficie lateral de {round(cono1.superficie_lateral(cono1.radio, cono1.altura), 2)}cm²')
print(f'El cono tiene un volumen de {round(cono1.volumen(cono1.radio, cono1.altura), 2)}cm³')

[@joaquingabrielminuso9182]

RETO
from math import sqrt
class Paralelepipedo:
"""
Clase para calcular todo sobre un cubo
"""
#Constructor
def __init__(self, height, broad, long):
self.height=height
self.broad=broad
self.long=long

#Metodo de instancia
def volume(self):
return self.height*self.broad*self.long

def area_total(self):
return 2*(self.height*self.broad + self.height*self.broad + self.broad*self.long)

def longitud_diagonal(self):
return sqrt(self.height**2 + self.broad**2 + self.long**2)

def perimetro_total(self):
return 4*(self.height + self.broad + self.long)

def __str__(self):
return (f'Altura: {self.height}
Ancho: {self.broad}
Largo: {self.long}')

if __name__ == '__main__':
paralelepipedo1=Paralelepipedo(10,12,15)
print(f'El Paralelepipedo calculado es:
{paralelepipedo1}')
print(f'El volumen del Paralelepipedo es {paralelepipedo1.volume()}')
print(f'El area del Paralelepipedo es {paralelepipedo1.area_total()}')
print(f'La longitud de la diafonal del Paralelepipedo es {paralelepipedo1.longitud_diagonal()}')
print(f'El perimetro del Paralelepipedo es {paralelepipedo1.perimetro_total()}')

[@12torotoro]

class Prism:
"""Surface Area and volume of a Rectangular Prism"""
def __init__(self, height, length, width):
self.height = height
self.length = length
self.width = width

def volume(self):
return self.height * self.length * self.width

def area(self):
return 2 * (self.width * self.length + self.height * self.length +
self.height * self.width)

def __str__(self):
return (f"Alrura: {self.height}
Largo: {self.length}
Ancho: {self.width}")
if __name__ == '__main__':
prism_a = Prism(2,3,4)
prism_b = Prism(1,1.5,2)

print(f"Prism 1:
{prism_a}")

[@HidroMentes]

from math import *
class Pitagoras:
"""
Calculo de la hipotenusa de un triangulo rectangulo
"""
def __init__(self, cateto_ad , cateto_op,):
self.cateto_ad = cateto_ad
self.cateto_op = cateto_op

def hipotenusa(self):
return sqrt(self.cateto_ad**2 + self.cateto_op**2)
def __str__(self):
return (f"
Cateto adyacente {self.cateto_ad}
Cateto opuesto {self.cateto_op}")
if __name__ == "__main__":
hipotenusa = Pitagoras(int(input("Ingrerse un numero : ")),int(input("Ingrerse otro numero : ")))
print(f"La hipotenusa es : {hipotenusa.hipotenusa()}")
print(f"Los valores de Triangulo son : {hipotenusa}")

[@carlosandreszamoramartinez3435]

reto:
from math import pi
class Esfera:
"""
Clase empleada para el cálculo de propiedades de la esfera
"""
#Método constructor:
def __init__(self,radio):
self.radio=radio

#Método mágico:
def __str__(self):
return (f'Radio: {self.radio}')

#Métodos de instancia:
def volumen(self):
return 4/3*pi*self.radio**3

def area_sombra(self):
return pi*self.radio**2

def area_superficial(self):
return 4*pi*self.radio**2
if __name__=='__main__':
esfera1=Esfera(3)
print(f'La esfera 1 posee:
{esfera1}')

[@alejandrosoria7862]

Hola Sergio.
Disculpa, que editor de texto utilizas ?

[@SergioACGiraldo]

Uso vários, pero en este caso estoy empleando el VS Code

[@gorra_roja]

from math import pi
class Esfera:
#Constructor
def __init__(self,radio,color):
self.radio=radio
self.color=color
#Instancia
def area(self):
return 4*pi*self.radio**2

def volumen(self):
return (4/3)*pi*self.radio**3

def __str__(self) -> str:
return (f"Esfera:
radio={self.radio}
volumen={self.volumen()}
area ={self.area()} ")
if __name__=="__main__":
esfera1=Esfera(2,"verde")
print(f"{esfera1}")

[@espiritu_vital]

No hay quien te entienda . No es nada didactico