Universidad “Mayor de San Andrés”
FACULTADA DE TECNOLOGIA
PRACTICA N°1
GRUPO “5”
DOCENTE: LIC. JUAN MARCOS MIRANDA NINA
Universitario: Vidaurre Mamani Luis Gonzalo
Saavedra Ticona Rosario Michelle
Carrera: Electrónica y Telecomunicaciones
Fecha: 23 de mayo de 2023
La Paz - Bolivia
EJEMPLO 1 EN EL EJEMPLO QUE SIGUE TRATA DE HALLAR EL PROMEDIO EL
PROMEDIO DE LAS CALIFICACIONES DE UN ALUMNO SU DIAGRAMA UML ES EL QUE
SIGUE
Alumno3
+String NombreAlum
+float calif1
+float calif2
+float calif3
+float calif4
+float promedio
+calcularPromedio()
+ObtenerNombreAlumn()
+ObtenerPromedio()
#1. calificaciones de un alumno
class alumno3:
def _init_(self):
self.__nombreAlumn=" "
self.__calif1=0.0
self.__calif2=0.0
self.__calif3=0.0
self.__calif4=0.0
self.__promedio=0.0
def getobtenerNombreAlumn(self):
return self.__nombreAlumn
def setestablecerNombreAlum(self,nom):
self.__nombreAlumn=nom
def setestablecerCalif1(self,ca1):
self.__calif1=ca1
def setestablecerCalif2(self,ca2):
self.__calif2=ca2
def setestablecerCalif3(self,ca3):
self.__calif3=ca3
def setestablecerCalif4(self,ca4):
self.__calif4=ca4
def getobtenerPromedio(self):
return self.__promedio
def calcularPromedio(self):
self.__promedio=(self.__calif1+self.__calif2+self.__calif3+self._
_calif4)/4
#main
nombreAlumn=""
c1=0.0
c2=0.0
c3=0.0
c4=0.0
promedio=0.0
print("CALCULA PROMEDIO DE UN ALUMNO")
nombreAlumn=input("Teclee nombre:")
c1=float(input("Teclee calificación 1:"))
c2=float(input("Teclee calificación 2:"))
c3=float(input("Teclee calificación 3:"))
c4=float(input("Teclee calificación 4:"))
alu3=alumno3()
print("--------------------Resultados--------------------")
[Link](nombreAlumn)
alu3.setestablecerCalif1(c1)
alu3.setestablecerCalif2(c2)
alu3.setestablecerCalif3(c3)
alu3.setestablecerCalif4(c4)
[Link]()
print("Nombre= ",[Link]())
print("Promedio= ",[Link]())
EJEMPLO 2
EN EL EJEMPLO QUE SIGUE HACE CÁLCULOS LOGARITMITICOS DE ANGULO SU DIAGRAMA
UML ES EL QUE SIGUE :
Anugulo5
+double tamAngulo
++double senAng
+double cosAng
+establecerTamAngulos(double ang)
+calcularSenAng()
+calcularCosAng()
#2. En el ejemplo que sigue hace calculos logaritmicos de angulo
import math
class angulo5:
def _init_(self) :
self.__tamAngulo=0.0
self.__senAng=0.0
self.__cosAng=0.0
def setestablecerTamAngulo(self,ang):
self.__tamAngulo=ang
def calcularSenAng(self):
self.__senAng=[Link](self.__tamAngulo)
def calcularCosAng(self):
self.__cosAng=[Link](self.__tamAngulo)
def getobtenerSenAng(self):
return self.__senAng
def getobtenerCosAng(self):
return self.__cosAng
#main
ang=angulo5()
print("CALCULOS LOGARITMICOS DE ANGULO")
print("----------------Lectura de dato----------------")
tamAng=float(input("Teclee tamaño del angulo en radianes:"))
[Link](tamAng)
[Link]()
[Link]()
print("--------------------Resultados--------------------")
print("Seno= ",[Link]())
print("Coseno= ",[Link]())
EJEMPLO 3 .- EN EL EJEMPLO QUE SIGUE, CALCULAR EL ÁREA DE UN TRIÁNGULOS, SU
DIAGRAMA UML ES EL QUE SIGUE .
AreaTriangulo2
+double baseTria
+double alturaTria
+doubleareaTria
+establecerBaseTria(double base)
+establecerAltura(double altura)
+calcularAreaTria()
+double calcularAreaTria()
+double ObtenerAreaTria()
#Calcule el area de un triangulo
class AreaTriangulo2:
def _init_(self):
self.__baseTria=0.0
self.__alturaTria=0.0
self.__areaTria=0.0
def setEstablecerBaseTria(self,base):
self.__baseTria=base
def setEstabelecerAlturaTria(self,altura):
self.__alturaTria=altura
def calcularAreaTria(self):
self.__areaTria=(self.__baseTria*self.__alturaTria)/2
def getObtenerAreaTria(self):
return self.__areaTria
class EjecutaAreaTriangulo2:
def _init_(self) :
print("----------------Lectura de dato----------------")
[Link]=float(input("Teclee base:"))
[Link]=float(input("Teclee altura:"))
at=AreaTriangulo2()
[Link]([Link])
[Link]([Link])
[Link]()
print("----------------Resultado----------------")
print("Area= ",[Link]())
#main
arTria=EjecutaAreaTriangulo2()
EJEMPLO 4
EN EL EJEMPLO QUE SIGUE CALCULA EL SUELTO DE UN EMPLEADO SU DIAGRAMA
UML ES EL QUE SIGUE
Empleado5
+String nombreEmp
+int horasTrab
+float cuotaHorra
+float sueldo
+void calcularSueldo()
#Calcula el sueldo de un empleado
class Empleado5:
def _init_(self):
self.__nombreEmp=" "
self.__horasTrab=0
self.__cuotaHora=0.0
self.__sueldo=0.0
def setEstablecerNombreEmp(self,nom):
self.__nombreEmp=nom
def setEstablecerHorasTrab(self,horasTr):
self.__horasTrab=horasTr
def setEstablecerCuotaHora(self,cuotaHr):
self.__cuotaHora=cuotaHr
def calcularSueldo(self):
self.__sueldo=self.__horasTrab*self.__cuotaHora
def getObtenerNombreEmp(self):
return self.__nombreEmp
def getObtenerSueldo(self):
return self.__sueldo
class EjecutaEmpleado5:
def _init_(self):
print("----------------Lectura de dato----------------")
[Link]=input("Teclee nombre:")
[Link]=int(input("Teclee horas trabajadas:"))
[Link]=float(input("Teclee cuota por hora:"))
[Link]=Empleado5()
[Link]([Link])
[Link]([Link])
[Link]([Link])
[Link]()
print("----------------Resultados----------------")
print("Nombre= ",[Link]())
print("Sueldo= ",[Link]())
#main
sueldoE=EjecutaEmpleado5()
EJEMPLO 5
EN EL EJEMPLO QUE SIGUE CALCULA LA HIPOTENUSA DE UN TRIANGULO SU
DIAGRAMA UML ES EL QUE SIGUE
Hipotenusa2
+double a
+double b
+double c
+void establecerA(double cateoA)
+void establecerB(double cateoB)
+void calcularC()
#Calcula la hipotenusa de un triangulo
import math
class Hipotenusa2:
def _init_(self):
self.__a=0.0
self.__b=0.0
self.__c=0.0
def setEstablecerA(self,catetoA):
self.__a=catetoA
def setEstablecerB(self,catetoB):
self.__b=catetoB
def calcularC(self):
self.__c=[Link](pow(self.__a,2)+pow(self.__b,2))
def getObtenerC(self):
return self.__c
class EjecutaHipotenusa2:
def _init_(self):
print("CALCULA HIPOTENUSA")
print("----------------Lectura de dato----------------")
[Link]=float(input("Teclee cateto A:"))
[Link]=float(input("Teclee cateto B:"))
[Link]=Hipotenusa2()
[Link]([Link])
[Link]([Link])
[Link]()
print("----------------Resultados----------------")
print("Hipotenusa C= ",[Link]())
#main
Hipo=EjecutaHipotenusa2()
EJEMPLO 6
EN EL EJEMPLO QUE SIGUE CALCULA EL PRECIO DE VENTA DE UN PRODUCTO SU
DIAGRAMA UML ES EL QUE SIGUE
PrecioArticulo2
+String descripción
+float costo
+float precioVta
+void establecerDescripcion(Stringe des)
+void establecerCosto(float co)
+void calcularPrecioVta()
#Calcula el precio de venta de un producto
class PrecioArticulo2:
def _init_(self):
self.__descripcion=" "
self.__costo=0.0
self.__precioVta=0.0
def setEstablecerDescripcion(self,des):
self.__descripcion=des
def setEstablecerCosto(self,co):
self.__costo=co
def calcularPrecioVta(self):
self.__precioVta=self.__costo+(self.__costo*1.2)+(self.__costo+(s
elf.__costo*1.2))+0.15
def getObtenerDescripcion(self):
return self.__descripcion
def getObtenerPrecioVta(self):
return self.__precioVta
class EjecutaPrecioArticulo2:
def _init_(self):
print("CALCULA PRECIO DE VENTA DE UN ARTICULO")
print("---------------Lectura de datos---------------")
pa=PrecioArticulo2()
[Link]=input("Teclee descripcion del articulo:")
[Link]=float(input("Teclee el costo de producción:"))
[Link]([Link])
[Link]([Link])
[Link]()
print("-----------------Resultados-----------------")
print("Articulo= ",[Link]())
print("Precio de venta= ",[Link]())
#main
precioArt=EjecutaPrecioArticulo2()
EJEMPLO 7.- EN EL EJEMPLO QUE SIGUE, CONVIERTE DE RADIANES A GRADOS Y GRADOS A
RADIANES, SU DIAGRAMA UML ES EL QUE SIGUE:
RadianGrado2
+double radianes
+double grados
+double numRadianes
+double numGrados
+void establecerRadianes(double rad)
+void establecerGrados(double gra)
+void calcularNumGrados()
#Convierte de radianes a grados y grados a radianes
class radiangrado2:
def _init_(self):
self.__radianes=0.0
self.__grados=0.0
self.__numRadianes=0.0
self.__numGrados=0.0
def setEstablecerRadianes(self,rad):
self.__radianes=rad
def setEstablecerGrados(self,gra):
self.__grados=gra
def calcularNumradianes(self):
self.__numRadianes=self.__grados*(3.1416/180)
def calcularNumGrados(self):
self.__grados=self.__radianes*(180/3.1416)
def getObtenerNumRadianes(self):
return self.__numRadianes
def getObtenerNumGrados(self):
return self.__numGrados
class EjecutaRadianGrado2:
def _init_(self):
print("CONVIERTE RADIANES A GRADOS Y GRADOS A RADIANES")
print("-----------------Lectura de datos----------------")
[Link]=float(input("Teclee numero de radianes:"))
[Link]=float(input("Teclee número de grados:"))
gr=radiangrado2()
[Link]([Link])
[Link]([Link])
[Link]()
[Link]()
print("---------------Resultados----------------")
print("Numero de grados= ",[Link]())
print("Numero de radianes= ",[Link]())
#main
gradrad=EjecutaRadianGrado2()