<jupyter_start><jupyter_text>Cap3 Problemas Python  Estos son problemas son del cap3 usando programación orientada a objetos<jupyter_code>import math<jupyter_output><empty_output><jupyter_text>1. Cree una clase llamada empleado que contenga como atributos los datos: nombre y número de empleado, y como métodos asignar ( ) y verdatos ( ).<jupyter_code>class empleado():
    def __init__(self, nombre, numero):
        self.nombre = nombre
        self.numero = numero
    
    def asignar(self):
        print("El atributo ha sido asignado")
    def verdatos(self):
        print("El empleado {} tiene un numero {} ".format(self.nombre, self.numero))
        
fernando = empleado("Fernando", 17)
fernando.asignar()
fernando.verdatos()<jupyter_output>El atributo ha sido asignado
El empleado Fernando tiene un numero 17<jupyter_text>2. Defina una clase que contenga tres datos enteros correspondientes a las edades del padre, la madre y el hijo. Cree un método que calcule el promedio de las tres edades.<jupyter_code>class familia():
    def __init__(self, padre, madre, hijo):
        self.padre = padre
        self.madre = madre
        self.hijo = hijo
    
    def promedio(self):
        promedio = (self.padre+self.madre+self.hijo)/3
        print(round(promedio,2))

Arosemena = familia(50,51,17)
Arosemena.promedio()<jupyter_output>39.33<jupyter_text>3. Una editorial desea crear fichas que almacenen título y precio de cada publicación. Cree la clase correspondiente y llámela Publicación; debe incluir los datos descritos.<jupyter_code>class publicacion():
    def __init__(self, titulo, precio):
        self.titulo = titulo
        self.precio = precio
    def crear_ficha(self):
        print("La ficha {} tiene un precio de {} $".format(self.titulo, self.precio)) 

a = publicacion("Cervantes", 50)
a.crear_ficha()<jupyter_output>La ficha Cervantes tiene un precio de 50 $<jupyter_text>4. Leer un número, elevar el número al cuadrado y al cubo, e imprimir el número junto con su cuadrado y cubo.<jupyter_code>n = float(input("Inserta un numero: "))
n_cuadrado = n**2
n_cubo = n**3
print("El cuadrado es {}, y el cubo es {}".format(n_cuadrado, n_cubo))<jupyter_output>Inserta un numero: 10
El cuadrado es 100.0, y el cubo es 1000.0<jupyter_text>5. Calcular la ecuación (operación en el libro) (A+B)/C * (D)<jupyter_code>A = float(input("Inserta el valor de A: "))
B = float(input("Inserta el valor de B: "))
C = float(input("Inserta el valor de C: "))
D = float(input("Inserta el valor de D: "))

resultado = ((A+B)/C)*D
print("El resultado es ", resultado)<jupyter_output>Inserta el valor de A: 5
Inserta el valor de B: 5
Inserta el valor de C: 2
Inserta el valor de D: 5
El resultado es  25.0<jupyter_text>6. Dados los tres lados de un triángulo A, B y C, encontrar el área.  Area = √ S(S-A)(S-B)(S-C) donde: S = (A+B+C)/2<jupyter_code>class triangulo():
    def __init__(self, A, B, C):
        self.A = A
        self.B = B
        self.C = C
    def area(self):
        S = (self.A+self.B+self.C)/2
        area = math.sqrt(S*(S-self.A)*(S-self.B)*(S-self.C))
        print("El área es: ", round(area,2))
        
t = triangulo(25,35,45)
t.area()<jupyter_output>El área es:  435.31<jupyter_text>7. Evaluar la ecuación y = ax2 + bx + c. Imprimir el valor de y.<jupyter_code>class ecuacion():
    def __init__(self, a,b,c,x):
        self.a = a
        self.b = b
        self.c = c
        self.x = x
    def resultado(self):
        y = self.a*self.x**2 + self.b*self.x + self.c
        print("El resultado es ", resultado)

a = ecuacion(2,3,5,7)
a.resultado()<jupyter_output>El resultado es  25.0<jupyter_text>8. Escriba un algoritmo que lea las longitudes de los cuatro lados de un cuadrado, y calcule e imprima el área del mismo.<jupyter_code>class cuadrado():
    def __init__(self,a,b,c,d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d
    def area(self):
        area = self.a**2
        print("El area es ", area)
cuadrado_1 = cuadrado(2,2,2,2)
cuadrado_1.area()
import math<jupyter_output><empty_output><jupyter_text>1.  Calcular el área de un triángulo (1/2*b*h). Imprimir los datos de entrada y el resultado.<jupyter_code>class triangulo():
    def __init__(self, base, altura):
        self.base = base
        self.altura = altura
        print("Se ha creado un triangulo con base de {} y altura {}".format(base, altura))
    def calcular_area(base, altura):
        area = (1/2)*base*altura
        print(area)
t = triangulo(15.,12)
t = triangulo.calcular_area(15.,12)<jupyter_output>Se ha creado un triangulo con base de 15.0 y altura 12
90.0<jupyter_text>2. Calcular el área de un círculo dado el radio (π r) e imprimir el area<jupyter_code>class circulo():
    def __init__(self, radio=0):
        self.radio = radio
        print("Has creado un circulo de radio {}".format(radio))
    def calcular_area_circulo(self):
        area_circulo = math.pi * self.radio
        print(area_circulo)
c = circulo(2)
c.calcular_area_circulo()<jupyter_output>Has creado un circulo de radio 2
6.283185307179586<jupyter_text>3. Calcular los grados Fahrenheit (F = 9/5 ( C° + 32)) dados los centígrados. Imprimir el resultado.<jupyter_code>class grados_fahrenheit():
    def __init__(self, centigrados):
        self.centigrados = centigrados
    def calcular_grados_fahrenheit(self):
        grados_fahrenheit = (9/5)*(self.centigrados + 32)
        print(grados_fahrenheit)
f = grados_fahrenheit(35)
f.calcular_grados_fahrenheit()<jupyter_output>120.60000000000001<jupyter_text>4. Calcular el salario de un empleado a partir de los siguientes datos de entrada: nombre del empleado, horas trabajadas, tarifa por hora, total de deducciones.<jupyter_code>class empleado():
    def __init__(self, nombre=0, horas_trabajadas=0, tarifa_hora=0, deducciones=0):
        self.nombre = nombre
        self.horas_trabajadas = horas_trabajadas
        self.tarifa_hora = tarifa_hora
        self.deducciones = deducciones
    def calcular_salario(self):
        print("Empleado: {}".format(self.nombre))
        print("Horas trabajadas: {}".format(self.horas_trabajadas))
        print("Tarifa por hora: {}".format(self.tarifa_hora))
        print("Deducciones: {}".format(self.deducciones))
        salario = (self.horas_trabajadas*self.tarifa_hora)-self.deducciones
        print("Tu salario es {}".format(salario))
fernando = empleado("Fernando",80,100,500)
fernando.calcular_salario()<jupyter_output>Empleado: Fernando
Horas trabajadas: 80
Tarifa por hora: 100
Deducciones: 500
Tu salario es 7500<jupyter_text>5. Calcular salario bruto = tarifa por horas * horas trabajadas y el salario neto = salario bruto– deducciones. Imprimir salario bruto y salario neto.<jupyter_code>class salario():
    def __init__(self,horas_trabajadas=0, tarifa_hora=50, deducciones = 500):
        self.horas_trabajadas = horas_trabajadas
        self.tarifa_hora = tarifa_hora
        self.deducciones = deducciones
    def calcular_salario_bruto(self):
        salario_bruto = self.tarifa_hora*self.horas_trabajadas
        return salario_bruto
    def calcular_salario_neto(self):
        salario_bruto = self.tarifa_hora*self.horas_trabajadas
        salario_neto = salario_bruto - self.deducciones
        print(salario_neto)
A = salario(100)
A.calcular_salario_bruto()
A.calcular_salario_neto()<jupyter_output>4500<jupyter_text>Solución general<jupyter_code>class Promedio():
    def __init__(self,listaDeNotas):
        self.listaDeNotas = listaDeNotas
    def CalcularPromedio(self):
        sumaDeNotas = 0.0
        for nota in self.listaDeNotas:
            sumaDeNotas += nota
        prom = sumaDeNotas/len(self.listaDeNotas)
        return prom
#(n1+n2+n3...etc)/(numero de notas)
pro = Promedio([4,5])
print(pro.CalcularPromedio())<jupyter_output>4.5<jupyter_text>5. Leer el nombre del estudiante y tres notas, calcular e imprimir la nota promedio.<jupyter_code>class estudiante():
    def __init__(self, nota1=0, nota2=0, nota3=0):
        self.nota1 = nota1
        self.nota2 = nota2
        self.nota3 = nota3
    def calcular_nota_promedio(self):
        nota_promedio = (self.nota1+self.nota2+self.nota3)/3
        return nota_promedio
Asley = estudiante(100,20,30)
Asley.calcular_nota_promedio()<jupyter_output><empty_output><jupyter_text>6. Leer dos números, calcular e imprimir el valor de suma, resta, producto y su división.<jupyter_code>class propiedades():
    def __init__(self,numero1=0, numero2=0):
        self.numero1 = numero1
        self.numero2 = numero2
    def suma(self):
        resultado_suma = self.numero1 + self.numero2
        print(resultado_suma)
    def resta(self):
        resultado_resta = self.numero1 - self.numero2
        print(resultado_resta)
    def producto(self):
        resultado_producto = self.numero1 * self.numero2
        print(resultado_producto)
    def division(self):
        resultado_division = self.numero1/self.numero2
        print(resultado_division)
        
numeros = propiedades(1,2)
numeros.suma()
numeros.resta()
numeros.producto()
numeros.division()<jupyter_output>3
-1
2
0.5<jupyter_text>7. Leer el largo, ancho y altura de una habitación. Calcular e imprimir cuántos metros cuadrados se requieren comprar de alfombra (área =largo × ancho), y cuántos metros cuadrados de papel se requieren para tapizar la pared de la habitación (P = 2 * largo * ancho * altura).<jupyter_code>class habitacion():
    def __init__(self, largo, ancho, altura):
        self.largo = largo
        self.ancho = ancho
        self.altura = altura
    def calcular_alfombra(self):
        alfombra = self.largo*self.ancho
        print(alfombra)
    def calcular_papel(self):
        papel = 2*(self.largo+self.ancho+self.altura)
        print(papel)
sala = habitacion(10,20,30)
sala.calcular_alfombra()
sala.calcular_papel()<jupyter_output>200
120<jupyter_text>8. Calcular e imprimir el precio de venta de un artículo. Se tienen los datos descripción del artículo y costo de producción. El precio de ventas se calcula añadiendo al costo el 12% como utilidad y el 15% de impuesto.<jupyter_code>class articulo():
    def __init__(self, descripcion, costo_produccion):
        self.descripcion = descripcion
        self.costo_produccion = costo_produccion
    def calcular_precio(self):
        utilidad = self.costo_produccion * 0.12
        impuesto = self.costo_produccion * 0.15
        precio = self.costo_produccion + utilidad + impuesto
        print("Es una {}, con un costo de {}".format(self.descripcion, precio))
naranja = articulo("naranja",20)
naranja.calcular_precio()<jupyter_output>Es una naranja, con un costo de 25.4<jupyter_text>9. Una niña deja caer su cartera desde el último piso de la torre Sears (1,454 pies de altura). Cree un algoritmo que calcule la velocidad de impacto al llegar al suelo. Utilizar la fórmula v = √ 2gh, donde h es la altura de la torre, g es la gravedad de 32 pies/seg 2<jupyter_code>class velocidad():
    def __init__(self, altura=1454, gravedad=32):
        self.altura = altura
        self.gravedad = gravedad
    def algoritmo(self):
        velocidad = math.sqrt(2*self.gravedad*self.altura)
        print(round(velocidad,2))
cartera = velocidad()
cartera.algoritmo()<jupyter_output>305.05<jupyter_text>10. Elabore un algoritmo que lea una cantidad de horas e imprima su equivalencia en minutos, segundos y días.<jupyter_code>class horas():
    def __init__(self, horas):
        self.horas = horas
    def calcular_equivalencias(self):
        minutos = self.horas * 60
        segundos = self.horas * 3600
        dias = self.horas/24
        print("Las {} horas insertadas son equivalentes a {} minutos {} segundos y {} dias".format(self.horas, minutos, segundos, dias))
a = horas(6)
a.calcular_equivalencias()<jupyter_output>Las 6 horas insertadas son equivalentes a 360 minutos 21600 segundos y 0.25 dias
{'fraction_non_alphanumeric': 0.10407698151430742, 'fraction_numerical': 0.02709546720688782, 'mean_word_length': 3.6941362916006337, 'pattern_counts': {'":': 0, '<': 67, '<?xml version=': 0, '>': 67, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '469377', 'license': 'MIT', 'n_tokens_mistral': 4580, 'n_tokens_neox': 4454, 'n_words': 1089, 'path': 'Cap3/Cap3 Problemas Python.ipynb', 'repo_name': 'FernandoCutire/Introducci-n-a-la-programaci-n-orientada-a-objetos', 'size': '11847'}