SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL
PLAN DE TRABAJO
DEL ESTUDIANTE
TRABAJO FINAL DEL CURSO
1. INFORMACIÓN GENERAL
Apellidos y Nombres: De La Cruz Rodríguez Victor Jhonatan. ID: 1474052.
Dirección Zonal/CFP: Cajamarca-Amazonas-San Martin.
Carrera: Ingeniería de software con inteligencia artificial. Semestre: III
Curso/ Mód. Formativo Programación orienta a objetos.
Tema del Trabajo: Implementa aplicación utilizando programación orientada a objetos.
2. PLANIFICACIÓN DEL TRABAJO
ACTIVIDADES/
N° CRONOGRAMA/ FECHA DE ENTREGA
ENTREGABLES
1 Entregable – E01 18/08/23
2
3
4
5
6
3. PREGUNTAS GUIA
Durante la investigación de estudio, debes obtener las respuestas a las siguientes interrogantes:
Nº PREGUNTAS
1 ¿Qué propiedades tendrá cada clase?
2 ¿Qué métodos deberá implementar cada clase?
¿Cuáles son las principales herramienta y bibliotecas necesarias para proceder
3
con el desarrollo?
4 ¿Sera necesario utilizar algún constructor? ¿Por qué?
¿Cómo diferenciamos la programación estructurada y la programación orienta a
5
objetos?
¿Cómo diferenciamos la programación estructurada y la programación orienta a
6
objetos?
2
TRABAJO FINAL DEL CURSO
HOJA DE RESPUESTAS A LAS PREGUNTAS GUÍA
1. ¿Qué propiedades tendrá cada clase?
Las propiedades de una clase pueden ser los: Atributos, métodos, los métodos de
acceso, los atributos estáticos, atributos constantes, métodos específicos, métodos
constructores, ámbitos públicos, protegidos y privados todas estas propiedades
definen el comportamiento de nuestra clase en la programación orienta a objetos.
2. ¿Qué métodos deberá implementar cada clase?
Los métodos que se deben implementar en cada clase dentro de la programación
orientada a objetos es lo dependen a la medida de los requisitos y funcionalidades
específicos de la programa. Lo cual también, hay algunos métodos comunes que a
menudo se implementan en las clases para proporcionar funcionalidad básica y
coherencia en el diseño.
3. ¿Cuáles son las principales herramienta y bibliotecas necesarias para proceder
con el desarrollo?
Algunas herramientas y bibliotecas generales que son comunes y útiles en el
desarrollo orientado a objetos pueden ser: Control de versiones, bibliotecas y marcos
(Librerías y Frameworks), depuradores, documentación, herramientas de prueba, las
cuales estas de aquí son algunas herramientas y bibliotecas comunes en el POO,
4. ¿Sera necesario utilizar algún constructor? ¿Por qué?
Sí, ya que utilizar un constructor en la programación orientada a objetos es una
práctica común y a menudo necesaria. Un constructor es un método especial que se
utiliza para inicializar los atributos de un objeto cuando se crea una instancia de una
clase. Los constructores tienen varias funciones y ventajas clave.
5. ¿Cómo diferenciamos la programación estructurada y la programación orienta a
objetos?
La programación estructurada se enfoca en control de flujo y modularidad, mientras
que la programación orientada a objetos se enfoca en la creación de objetos,
encapsulación, herencia y polimorfismo para modelar el mundo real de manera más
cercana.
6. ¿Cómo diferenciamos la programación estructurada y la programación orienta a
objetos?
En general y para mi, no hay una estructura de datos "mejor" en términos absolutos,
ya que la elección dependerá de las necesidades específicas de tu proyecto. Python
ofrece una amplia gama de estructuras de datos, y es importante entender sus
características y ventajas para tomar la decisión adecuada en función de los
requisitos de tu aplicación.
3
TRABAJO FINAL DEL CURSO
HOJA DE PLANIFICACIÓN
PROCESO DE EJECUCIÓN
SEGURIDAD /
OPERACIONES / PASOS /SUBPASOS MEDIO AMBIENTE
/ NORMAS -
ESTANDARES
Tarea 1: Desarrollar los conceptos del paradigma de la
Programación Orientada a Objetos.
PASO 1: Primero hice mi entrada por consola, lo cual usé el “print” ISO 20000:
y puse dentro de los parámetros y las comillas un “str” que son para Sistema de
cadenas de texto, luego de ello he creado mis 4 variables que les gestión
puse a cada una como nombre de variable: “Nombre”, “Categoría”; de servicios de
“Horas extras” y “Tardanza”. TI.
print("* DATOS DE ENTRADA *")
nombre
categoria
horas_extras
tardanzas
PASO 2: Después de haber creado mis cuatro variables con su
respectivo nombre puse los “input” que son ingresar texto dentro de ISO/IEC
ellos y luego puse los parámetros y dentro de las comillas puse 12207:2008:
ingresar nombre de trabajador, igual hice para la variable categoría, Procesos de
en la variable “Horas extras” puse el tipo de dato “int” que son para Ciclo de Vida
números enteros y luego puse “input” seguí con el procedimiento, lo del Software
mismo hice para la variable “Tardanza”
print("* DATOS DE ENTRADA *")
nombre = input("INGRESE NOMBRE DEL TRABAJADOR : ")
categoria = input("INGRESE LA CATEGORIA DEL TRABAJADOR (A, B ,
C): ")
horas_extras = int(input("INGRESE LAS HORAS EXTRAS DEL
TRABAJADOR : "))
tardanzas = int(input("INGRESE LAS TARDANZAS(en minutos) DEL
TRABAJADOR : "))
PASO 3: Después creada mi entrada por consola, he cree mi ISO 20000:
primera “CLASS” con el nombre “EntradaNombre” Alinear los
class EntradaNombre: servicios de TI
PASO 4: Después de crear mi clase, inicialice mi constructor junto a ISO/IEC
sus atributos, lo cual para ello defini con “DEF” y su el constructor 25010:2011:
“INIT que sirve para hacer el llamado a la instancia de la clase que Calidad del
creo, después de ello agregue los parámetros y puse el “self” dentro Producto de
del parámetro que eso de ahí sirve para hacer referencia al objeto Software
de mi clase que se manicula cuando se llama al método y después
agregue nada más ahí en mis parámetros los argumentos que son:
nombre, categoría, horas extras y tardanza.
def __init__(self, nombre, categoria, horasExtras, tardanzas):
4
TRABAJO FINAL DEL CURSO
PASO 5: Después de ello agregue mis atributos con la notación ISO/IEC/IEEE
self.nombre = nombre, y asi cree mis atributos para los demás, lo 42010:2011:
cual quedo asi. Arquitectura de
self.nombre = nombre Software y
self.categoria = categoria Descripción de
self.horas_extras = horasExtras Diseño
self.tardanzas = tardanzas
PASO 6: Después de ello he creado un metodo llamada ISO/IEC/IEEE
“pagoPorHoras” y luego tomo como mi parámetro que está dentro 15288:2015:
de ello el “self” como primer argumento lo cual este de aquí se va Ciclo de Vida de
ser referencia a la instancia o el objeto de mi clase actual cuando los Sistemas y
llamemos al método. Software de
def pagoPorHoras(self): Ingeniería
PASO 7: Después de ello agregue “if self.categoria == 'A': “ lo cual ISO/IEC/IEEE
este código me va servir si el atributo “categoria” es igual al “A”, ya 26512:2011:
que la variable self.categoria es el atributo de nuestra clase creada, Ingeniería de
luego declare “return 3000 / 240” , si la categoría es “A” nos va Requisitos de
devolver como resultado de la operación lo cual divide 3000 / 240, Software
lo cual nos devuelve este el cálculo de pago por hora para nuestra
categoría “A”, igual hice para la categoría “B” usando la condición
“elif” con el código “elif self.categoria == 'B':” lo cual si la categoría
anterior no es “A” en esta será la “B” y declaramos return como en
la condición anterior dividiendo 2500 entre 240 y nos devolverá el
resultado y podremos ver el cálculo de la categoría “B” y por ultimo
hice lo mismo con la categoría “C” si en la anterior no es la
categoría “A” ni “B” será la “C” y declaro return y divido 2000 entre
240 y nos devolverá el resultado, y veremos el cálculo de la
categoria “C”, lo cual todo esto pertenece y está definido dentro del
método “pagoPorHora”
def pagoPorHoras(self):
if self.categoria == 'A':
return 3000 / 240
elif self.categoria == 'B':
return 2500 / 240
elif self.categoria == 'C':
return 2000 / 240
PASO 9: Luego de eso agregue mi notación o mejor dicho agregue ISO 31000:
mi código “if self.categoria == “A”, lo cual Si self.categoria es igual a normas sobre
“A” se nos va establecer el sueldo 3000 en la variable gestión del
“sueldoBasico”, luego de eso calcule el pago por hora y lo puse la riesgo.
variable “phx” para dividir el “sueldoBasico” entre 240, después
declare el código “return phx * self.horas_extras” lo cual este de
aquí va devolver el resultado de pago de horas extras que es será
por el pago de “phx” multiplicado por el pago de horas extras que es
el “self.horas_extras” , lo mismo hice para categoría “B” lo cual use
la condición “elif” ya que si no cumple con la categoría “A” cumplirá
con la “B” y use el mismo proceso solo cambia el sueldo básico de
la categoría “B” que ahí seria 2500 su sueldo básico para la “B”, y si
no cumple con la “B” ni con la “A” cumplirá con la ultima categoría
5
TRABAJO FINAL DEL CURSO
que será la categoría “C”, lo cual va ser el mismo código y el mismo
proceso solo cambia su sueldo básico de la categoría lo cual aquí
seria 2000 y nos va devolver el resultado de pago por horas extras
usando el “return”.
def obtenerPagoDeHorasExtras(self):
if self.categoria == 'A':
sueldoBasico = 3000
phx = sueldoBasico / 240
return phx * self.horas_extras
elif self.categoria == 'B':
sueldoBasico = 2500
phx = sueldoBasico / 240
return phx * self.horas_extras
elif self.categoria == 'C':
sueldoBasico = 2000
phx = sueldoBasico / 240
return phx * self.horas_extras
PASO 10: Después de ello cree definí otro método llamado ISO 10006:
“obtenerDescuentoTardanza” después de eso puse mi parámetro y Gestión de la
de ello tuve mi primer argumento que es el “self” , después de eso Calidad en
declare mi código “return (self.pagoHoras () / 60) * self.tardanzas” lo Proyectos
cual en esta lindea de mi código me va servir para calcular el
descuento para la tardanza y después de ello me va devolver el
resultado cuando uso mi declaración “return”, y el self.pagoHoras es
lo que va calcular el pago en las horas trabajadas. Lo cual se va
dividir entre 60 y va sacar el calculo por minuto, y el “self.tardanzas”
esto va ser que multiplique el pago por minuto por el numero o
resultado de la tardanza del trabajador.
def obtenerDescuentoDeTardanza(self):
return (self.pagoPorHoras() / 60) *
self.tardanzas
PASO 11: Después de ello definí mi otro método llamado ISO/IEC 12207:
“obtenerSueldoNeto” luego agregue mis parámetros y dentro de ello Procesos de
puse “self” como primer parámetro, luego agregue mi código Ciclo de Vida
“sueldoBasico = self.pagoPorHoras()* 240, lo cual este código me del Software
va calcular el sueldo básico del trabajador, lo cual
self.pagoPorHoras va ser que obtenga el pagoPorHoras luego es el
que multiplica por 240 y resultado que nos de va ser asignado a la
variable que he creado que es el “sueldoBasico”. Luego de ello cree
mi otra variable que es:
“pagoDeHorasExtras=self.obtenerPagoDeHorasExtras()”
aquí hago el llamado a mi metodo obtenerPagoDeHorasExtras
trabajadas, lo cual el resultado se va asignar dentro de mi variable
creada que es “pagoDeHorasExtras”, después de eso cree mi otra
variable llamada “descuentoDeTardanzas” y dentro de ello puse
“self.obtenerDescuentoDeTardanza” lo cual hice similar a lo anterior
lo cual calculara el descuento a la tardanza y nos dará el resultado
6
TRABAJO FINAL DEL CURSO
a mi variable creada, y por ultimo cree mi última variable llamada
“sueldoNeto” y pues aquí para sacar el sueldo neto tuve sumar el
resultado de mi variable sueldoBasico + pagoDeHorasExtras y
luego lo reste por el descuentoDeTardanzas y el resultado que me
de va ser asignado a mi variable “sueldoNeto”
def obtenerSueldoNeto(self):
sueldoBasico = self.pagoPorHoras() * 240
pagoDeHorasExtras = self.obtenerPagoDeHorasExtras()
descuentoDeTardanza = self.obtenerDescuentoDeTardanza()
sueldoNeto = sueldoBasico + pagoDeHorasExtras -
descuentoDeTardanza
return sueldoNeto
PASO 12: Despues de eso, he creado otra clase llamada ISO/IEC 38501:
“trabajadorBoleta”, luego definí mi constructor que es el “init” para el Gestión de la
llamado a mi objeto creado dentro de esa clase, después agregue Sostenibilidad
los parámetros, lo cual dentro de ellos agregue mi primer parámetro de las TIC
llamado self, después puse mi otro argumento llamado trabajador,
luego he creado mi atributo con la notación lque es self.trabajador =
trabajador.
class trabajadorBoleta:
def __init__(self, trabajador):
self.trabajador = trabajador
PASO 13: Luego de eso defini mi metodo llamado “generar_boleta ISO/IEC 27001:
y agregue mi parámetro , luego de eso agregue mis “print” para que Seguridad de la
imprima por consolo, lo cual va imprimir primero que todo dentro de Información
los parámetros puse las comillas ya que ahí va ir mi “str” ósea
textos de cadena luego de ello va imprimir y va dar acceso a lo mi
atributo self.trabajador.nombre y va imprimir el nombre del
trabajador, lo mismo va hacer con mis demás atributos que he
creado con la notación respectiva y mostras sus valores.
def generar_boleta(self):
print("**** BOLETA DE PAGO ****")
print("NOMBRE:", self.trabajador.nombre)
print("CATEGORIA:", self.trabajador.categoria)
print("SUELDO BASICO:", self.trabajador.pagoPorHoras()
* 240)
print("PAGO HORAS EXTRAS:",
self.trabajador.obtenerPagoDeHorasExtras())
print("DESCUENTO TARDANZAS:",
self.trabajador.obtenerDescuentoDeTardanza())
print("SUELDO NETO:",
self.trabajador.obtenerSueldoNeto())
PASO 14: Luego de haber hecho todo eso, por ultimo agregue mi ISO/IEC 20000:
objeto ósea mi instancia, lo cual de nombre lo puso trabajador1 que Gestión de
esta dentro de mi clase principal que lo puse en el inicio de mi Servicios de TI
programa que es la clase “EntradaNombre” y dentro de mis
parámetros puse nombre, categoría, horas_extras, tardanza lo cual
va tomar esto como parámetros a la impresión que va ejecutar
dentro de la consola, después cree mi otro objeto llamado “boleta1
lo cual esta dentro de mi otra clase que he creado que se llama
7
TRABAJO FINAL DEL CURSO
“trabajadorBoleta” lo cual puse mi parámetro y dentro de ello va
tomarlo a mi objeto trabajador1 de clase “EntradaNombre”, para que
imprima la boleta del trabajador, pues por ultimo puse mi código
“boleta1.generar_boleta”, lo cual puse mi objeto boleta1 que es de
la clase trabajadorBoleta y va tomar al metodo donde esta
imprimiento la boleta que esta dentro de la clase trabajadorBoleta y
por consola me mostrara la boleta del trabajador que ingresos.
trabajador1 = EntradaNombre(nombre, categoria, horas_extras,
tardanzas)
boleta1 = trabajadorBoleta(trabajador1)
GENERAR BOLETA:
boleta1.generar_boleta()
HOJA DE PLANIFICACIÓN
PROCESO DE EJECUCIÓN
SEGURIDAD /
OPERACIONES / PASOS /SUBPASOS MEDIO AMBIENTE
/ NORMAS -
ESTANDARES
Tarea 2: Trabajar con encapsulación y ocultamiento
de la información.
PASO 1: Primero he creado mi clase llamada “Usuario”, después de ISO/IEC
eso definí mi constructor que es el “init” que va ser el llamado a mi 12207:2008:
objeto de mi clase creada, luego de eso agregué mis parámetros y Procesos de
dentro de ello puse mis argumentos, como primero tengo al “self” Ciclo de Vida
después tengo nombre, apellido, email y contraseña. Después de del Software
eso agregue mis atributos con su notación dada, lo cual seria
self.nombre = nombre, lo igual fue para mis demás atributos lo único
que cambio fueron los ámbitos, ya que para nombre es protegido y
se usa un punto y guion para apellido también fue ámbito protegido,
para email fue público ya que el email lo pueden ver todos pero ahí
use nada mas el punto y para mi atributo categoría fue ámbito
privado ya que se usa un punto y doble guion.
class Usuario:
def __init__(self, Nombre, Apellido, Email, Contraseña):
self._nombre = Nombre
self._apellido = Apellido
self.email = Email
self.__contraseña = Contraseña
PASO 2: Después de eso he creado mi método lo cual lo definí y ISO/IEC/IEEE
pues lo puse como nombre a mi método llamado “modificar” y 26512:2011:
agregue mis parámetros lo cual dentro de ello agregue mis Ingeniería de
argumentos, después agregue mis atributos con sus ámbitos como Requisitos de
hize lo mismo en mi anterior paso junto y definido cada atributo con Software
su ámbito lo cual use los tres ámbitos protegido, privado y público.
def modificar(self, Nombre=None, Apellido=None, Email=None,
Contraseña=None):
8
TRABAJO FINAL DEL CURSO
self._nombre = Nombre
self._apellido = Apellido
self.email = Email
self.__contraseña = Contraseña
PASO 3: Después de ello definí y agregue mi otro método llamado ISO 20000:
“obtenerInfo” y agregue igual mí mismo parámetro y declare “return Alinear los
{ } ” lo cual esto va devolver un diccionario, lo cual dentro de mi servicios de TI
diccionario ahí información que agregue y nos devolverá el
resultado de nuestro diccionario creado, lo cual dentro de ello están
mis atributos que he creado anteriormente con sus ámbitos.
def obtenerInfo(self):
return {
"nombre": self._nombre,
"apellido": self._apellido,
"email": self.email,
"contraseña": "*****"
}
PASO 4: Después de ello he creado mi objeto llamado usuario1 que
esta dentro de mi clase usuario y dentro de mis parámetros agregue
lo que la información que le pertenece a mis atributos.
usuario1 = Usuario("victor", "de la cruz", "[email protected]",
"victor1475")
PASO 5: Después de ello agregue lo que es el “print” lo cual esto va ISO/IEC 38501:
imprimir por consola la información o el resultado de mi clase que Gestión de la
es usuario, lo cual dentro de ello esta incluido lo que son nombres, Sostenibilidad
apellido, email y contraseña, luego agregue un diccionario llamado de las TIC
“infoUsuario ya que esto lo va obtener al método “obtenerInfo” de mi
objeto “usuario1” ya que luego de eso utiliza al diccionario para que
así pueda acceder o ingresar a la información que esta dentro de
los “print” y se pueda ejecutar por la consola.
print("INFORMACION DEL USUARIO")
infoUsuario = usuario1.obtenerInfo()
print("Nombre:", infoUsuario["nombre"])
print("Apellido:", infoUsuario["apellido"])
print("Email:", infoUsuario["email"])
print("Contraseña:", infoUsuario["contraseña"])
PASO 6: Luego de eso puse nuevamente el nombre de objeto que ISO/IEC 27001:
es “usuario1” que es de mi clase y esta dentro de “usuario” ye hice Seguridad de la
un llamado a mi método “modificar” lo cual esto va hacer una Información
actualización en mis atributos creados que hice con sus valores o
su información que definí, lo cual esto puede usarse para cambiar la
información o los valores de mi clase usuario.
usuario1.modificar(Nombre="jerson", Apellido="garcia",
Email="[email protected]", Contraseña="victor0077")
PASO 7: Despues de ello agregue por ultimo, mis últimos “print” ISO/IEC 20000:
para que por consola muestre la informacion modificada del usuario, Gestión de
incluyendo su nombre, apellido, email y contraseña, luego nada Servicios de TI
mas ahí puse el diccionario que lo puse “infoModificado” que esta
haciendo un llamado a mi metodo “obtenerInfo” que esta dentro de
mi objeto de “usuario1” ya que por ultimo segui con los “print” y se
9
TRABAJO FINAL DEL CURSO
utilizara la información o resultado de mi diccionario para acceder a
la información actualizada de mi clase usuario.
print("\nMODIFICACION DEL USUARIO")
infoModificado = usuario1.obtenerInfo()
print("Nombre:", infoModificado["nombre"])
print("Apellido:", infoModificado["apellido"])
print("Email:", infoModificado["email"])
print("Contraseña:", infoModificado["contraseña"])
INSTRUCCIONES: debes ser lo más explícito posible. Los gráficos ayudan a transmitir
mejor las ideas. No olvides los aspectos de calidad, medio ambiente y SHI.
VAYA A LA SIGUIENTE HOJA…
10
TRABAJO FINAL DEL CURSO
DIBUJO / ESQUEMA/ DIAGRAMA
Tarea 1: Desarrollar los conceptos del paradigma de la Programación
Orientada a Objetos.
MI CODIGO:
print("* DATOS DE ENTRADA *")
nombre = input("INGRESE NOMBRE DEL TRABAJADOR : ")
categoria = input("INGRESE LA CATEGORIA DEL TRABAJADOR (A, B , C): ")
horas_extras = int(input("INGRESE LAS HORAS EXTRAS DEL TRABAJADOR : "))
tardanzas = int(input("INGRESE LAS TARDANZAS(en minutos) DEL TRABAJADOR : "))
class EntradaNombre:
def __init__(self, nombre, categoria, horasExtras, tardanzas):
self.nombre = nombre
self.categoria = categoria
self.horas_extras = horasExtras
self.tardanzas = tardanzas
def pagoPorHoras(self):
if self.categoria == 'A':
return 3000 / 240
elif self.categoria == 'B':
return 2500 / 240
elif self.categoria == 'C':
return 2000 / 240
def obtenerPagoDeHorasExtras(self):
if self.categoria == 'A':
sueldoasico = 3000
phx = sueldoBasico / 240
return phx * self.horas_extras
elif self.categoria == 'B':
sueldoBasico = 2500
phx = sueldoBasico / 240
return phx * self.horas_extras
elif self.categoria == 'C':
sueldoBasico = 2000
phx = sueldoBasico / 240
return phx * self.horas_extras
def obtenerDescuentoDeTardanza(self):
return (self.pagoPorHoras() / 60) * self.tardanzas
11
TRABAJO FINAL DEL CURSO
def obtenerSueldoNeto(self):
sueldoBasico = self.pagoPorHoras() * 240
pagoDeHorasExtras = self.obtenerPagoDeHorasExtras()
descuentoDeTardanza = self.obtenerDescuentoDeTardanza()
sueldoNeto = sueldoBasico + pagoDeHorasExtras - descuentoDeTardanza
return sueldoNeto
class trabajadorBoleta:
def __init__(self, trabajador):
self.trabajador = trabajador
def generar_boleta(self):
print("* BOLETA DE PAGO *")
print("NOMBRE:", self.trabajador.nombre)
print("CATEGORIA:", self.trabajador.categoria)
print("SUELDO BASICO:", self.trabajador.pagoPorHoras() * 240)
print("PAGO HORAS EXTRAS:", self.trabajador.obtenerPagoDeHorasExtras())
print("DESCUENTO TARDANZAS:",
self.trabajador.obtenerDescuentoDeTardanza())
print("SUELDO NETO:", self.trabajador.obtenerSueldoNeto())
trabajador1 = EntradaNombre(nombre, categoria, horas_extras, tardanzas)
boleta1 = trabajadorBoleta(trabajador1)
boleta1.generar_boleta()
EJECUCION POR CONSOLA:
12
TRABAJO FINAL DEL CURSO
Tarea 2: Trabajar con encapsulación y ocultamiento de la
información.
MI CODIGO:
class Usuario:
def __init__(self, Nombre, Apellido, Email, Contraseña):
self._nombre = Nombre
self._apellido = Apellido
self.email = Email
self.__contraseña = Contraseña
def modificar(self, Nombre=None, Apellido=None, Email=None,
Contraseña=None):
self._nombre = Nombre
self._apellido = Apellido
self.email = Email
self.__contraseña = Contraseña
def obtenerInfo(self):
return {
"nombre": self._nombre,
"apellido": self._apellido,
"email": self.email,
"contraseña": "*****"
}
usuario1 = Usuario("victor", "de la cruz", "[email protected]", "victor1475")
print("INFORMACION DEL USUARIO")
infoUsuario = usuario1.obtenerInfo()
print("Nombre:", infoUsuario["nombre"])
print("Apellido:", infoUsuario["apellido"])
print("Email:", infoUsuario["email"])
print("Contraseña:", infoUsuario["contraseña"])
usuario1.modificar(Nombre="jerson", Apellido="cueva",
Email="[email protected]", Contraseña="victor0077")
print("\nMODIFICACION DEL USUARIO")
infoModificado = usuario1.obtenerInfo()
print("Nombre:", infoModificado["nombre"])
print("Apellido:", infoModificado["apellido"])
print("Email:", infoModificado["email"])
print("Contraseña:", infoModificado["contraseña"])
EJECUCION POR CONSOLA:
13
TRABAJO FINAL DEL CURSO
[NOMBRE DEL TRABAJO]
[APELLIDOS Y NOMBRES] [ESCALA]
14
TRABAJO FINAL DEL CURSO
LISTA DE RECURSOS
INSTRUCCIONES: completa la lista de recursos necesarios para la ejecución del trabajo.
1. MÁQUINAS Y EQUIPOS
PC de la institución senati
Celular
Laptop
3. HERRAMIENTAS E INSTRUMENTOS
Word
Visual studio
chrome
5. MATERIALES E INSUMOS
15
