LENGUAJES DE PROGRAMACIÓN

II Ciclo

Laboratorio 8: POO Programación Orientada a NOTA

Objetos

Alumnos: BENDEZU DELZO MOISES ERNESTO

Fecha de realización: 17-05-2023

Fecha de entrega: 17-05-2023

1. Objetivos
● Comprender el uso de Listas y Diccionarios
● Identificar los usos y tipos de Listas y Diccionarios
● Implementar aplicaciones con Listas y Diccionarios

Equipos y Materiales
Una computadora con:
● Windows 7 o superior
● Conexión a la red
● Software de desarrollo

2. Fundamento Teórico
Orientado a objetos: Un programa se hace de muchos objetos que cooperan entre sí. En vez de ser
un “programa entero” – cada objeto es una pequeña “isla” dentro de un programa que coopera con
otros objetos para trabajar.
Un programa está hecho de uno o más objetos trabajando juntos - objetos que hacen uso de las
capacidades de los demás.
Los conceptos que debemos manejar son:
- Objeto
- Clase
- Atributo
- Método
- Instancia
Objeto: Un Objeto es una parte de Código auto-contenido y Datos, un aspecto principal del método
orientado a objetos es dividir el problema en partes más pequeñas y comprensibles (divide y
vencerás). Los objetos tienen límites que nos permiten ignorar detalles innecesarios.
Hemos estado utilizando objetos todo este tiempo: Objetos de Cadenas, Objetos Enteros, Objetos
de Diccionarios, Objetos de Listas, etc.
Los objetos tienen datos y funcionalidades.
Clase: es una plantilla que contiene la estructura básica del objeto que me sirve para crear nuevos
objetos
Atributo o Campo: son los datos o una parte de los datos en una clase
Nombres
Apellidos
Correo
Contraseña
Premium
Método o Mensaje: son las funcionalidades, la capacidad definida de una clase
 Iniciar sesión
Cerrar sesión
Editar perfil
Cambiar contraseña
Pasar a premium
Publicar en comunidad
Instancia o Instanciar: Crear objetos a partir de una clase. Ejemplo: El objeto Lassie es una instancia
de la clase Perro.
La instancia es el objeto creado en tiempo de ejecución a partir de una clase.
Podemos crear muchos objetos, la clase es la plantilla para el objeto, podemos almacenar cada
objeto distinto en su propia variable, llamamos a esto tener múltiples instancias de la misma clase.
Cada instancia tiene su propia copia de las variables de instancia

Paradigma de POO: La forma cómo resolver problemas de programación, existen diferentes

paradigmas y uno de esos paradigmas es la programación orientada a objetos.
Como paradigma la programación orientada a objetos se basa en cuatro pilares:
- Abstracción
- Encapsulamiento
- Polimorfismo
- Herencia
Abstracción: proceso mental para decidir qué métodos y atributos debemos usar.
Encapsulamiento: La forma de cómo proteger la información, para que solo se pueda acceder a los
datos permitidos.
Poliformismo: La forma en la que cada objeto responde de manera particular
Herencia: Las clases hijas heredan las propiedades de las clases padres con nuevos atributos y
métodos.
Constructor: El propósito principal de un constructor es configurar algunas variables de instancia
para tener los valores iniciales apropiados cuando el objeto es creado.
Destructor: Se utiliza para eliminar variables, rara vez es usado.

3. Procedimiento:
Usando objetos:
Curiosamente durante nuestras clases hemos estado utilizando objetos todo este tiempo, Python
contiene muchos objetos incluidos. He aquí un programa sencillo, cuyas primeras líneas deberían
resultarte sumamente simples y familiares.
self: La palabra “self” es usada para representar la instancia de la clase, al usar la palabra reservada
“self” podemos acceder a los atributos y métodos de una clase.

1
Ejercicio 1: Copiar el programa de abajo, compilar, analizar y comentar lo que sucede.

Cada método parece una función: comienzan con la palabra clave def y consisten en un bloque de
código indentado. Este objeto tiene un atributo (x) y un método (grupo). Los métodos tienen un
primer parámetro especial al que, por convención, llamamos self.
Tal como la palabra clave def no causa que el código de una función se ejecute, la palabra clave
class no crea un objeto. En vez, la palabra clave class define una plantilla que indica qué datos y
código contendrá cada objeto de tipo GrupoAnimal.

#Clases
class padre:
x = 0 #Atributos: Datos
def metodo(self) : #Métodos: Funciones
self.x = self.x + 1
print("Hasta ahora",self.x)
hija = padre()
hija.metodo()
hija.metodo()
hija.metodo()
padre.metodo(hija)

Comentario: En este código creamos una clase llamada padre a la que cargamos el dato
x=0 definimos el método con el parámetro self porque queremos que esta sea una clase
padre, luego colocamos una ecuación para sumar el valor de x padre más 1 para luego
cargar el resultado en x, se imprime x.

2
Ejercicio 2: Copiar el programa de abajo, compilar, analizar y comentar lo que sucede.

Comentario: En este ejercicio nos dan varios métodos para hacer varias clases con el dir(),
doc(),subclasshook(), hablamos de algo más interesante como el getstate devuelve un
objeto conteniendo el estado actual del generador de números aleatorios.

3
Ejercicio 3: Copiar el programa de abajo, compilar, analizar y comentar lo que sucede.

Comentario: En este código creamos una clase padre llamada “padre” a la cual le damos el
dato x = 0, luego definimos la función init que será el constructor del ciclo de vida de la clase
“padre” luego definimos la función “método” donde sumamos 1 a x y el resultado se carga en
x, finalmente definimos la función del para para terminar la ejecución de la clase “padre”, init
imprime “estoy construido”, método imprime “hasta ahora” y el valor de x y del imprime
“Estoy destruido” y el valor de x. Luego creamos la clase hija “hija” a partir de la clase
“padre”, luego ejecutamos la función “método” de la clase hija dos veces, ahora se carga el
valor 42 a la variable hija. Finalmente imprimimos “hija contiene” y el valor de la variable
“hija”.

4
Múltiples instancias:
Ejercicio 4: Copiar el programa de abajo, compilar, analizar y comentar lo que sucede.

Comentario: Le agregamos un precargado valor Con la hijas 1 , hijas 2, también le estamos

creando un dato inicial y creamos una función llamado grupo() para poder realizar este
proceso.

5
Ejercicio 5: Del ejercicio anterior guardar solo la clase padre en un archivo familia.py, copiar el
programa de abajo, compilar, analizar y comentar lo que sucede.

Comentario: Primero importamos la clase “padre” del módulo “familia”, luego creamos la
clase “vecinos” que hereda los métodos de la clase padre “padre”, esta tiene el dato: puntos
= 0, luego se define el método seis que suma 6 al valor de x, dentro de “seis” se crea el
metodo grupo que viene del módulo familia. después se imprime el valor de “nombre” de la
clase padre, el valor de “puntos”, ahora creamos la clase hija “s” de la clase padre con el
parámetro “Sally”, despues se ejecuta el metodo “grupo”, se crea la clase j hija de “vecinos”
con el parámetro “Jim”, luego se ejecuta el metodo grupo, ahora el método seis y finalmente
se imprime el directorio de métodos de la clase j.

Ejercicio 6: Crear un programa (objeto) para visualizar una ventana. Copiar el programa de abajo,
compilar, analizar y comentar lo que sucede.

#Crear una ventana con Tkinter

from tkinter import * # "*" para importar todas las librerías

class Alumno: #creamos nuestra clase

def __init__(self,ventana):
self.ventana = ventana
self.ventana.title("Hola mundo") #Nos da el título de la ventana
self.ventana.geometry("400x300") #Nos da el tamaño de la ventana
if __name__ == "__main__":
ventana = Tk() #Instanciamos la clase Tk()
aplicacion = Alumno(ventana) #instanciamos la clase Alumno
#convertimos ventana en el loop principal
#que va a estar refrescando por si realizamos un cambio
ventana.mainloop()

6
Comentario: IF_NAME estoy creando mis propias ventanas porque puedo hacer varias
clases, puedo crear varias clases encima del otro. con el tk(es la clase ventana) y he creado
mi propia ventana inicial.

7
Ejercicio 7: Crear un programa (objeto) para visualizar una ventana y un comentario. Copiar el
programa de abajo, compilar, analizar y comentar lo que sucede.

#Crear una ventana con Tkinter

from tkinter import * # "*" para importar todas las librerías
class Alumno: #creamos nuestra clase
def __init__(self,ventana):
self.ventana = ventana
self.ventana.title("Lenguajes de Programación")
self.ventana.geometry("400x300") #Nos da el tamaño de la ventana
Label(self.ventana, text = "Hola Mecatrónico",bg =
"pink").grid(row=0,column=0)

if __name__ == "__main__":
ventana = Tk() #Instanciamos la clase Tk()
aplicacion = Alumno(ventana) #instanciamos la clase Alumno
#convertimos ventana en el loop principal
#que va a estar refrescando por si realizamos un cambio
ventana.mainloop()

Comentario: en este código creamos una ventana usando la librería tkinter, se crea la clase
“Alumno” en esta se crea el método “init” con los parámetros self y ventana, luego a la
ventana se le da el título “Lenguajes de Programación”, después definimos su geometría y
creamos una etiqueta con el texto “Hola Mecatrónico” con el fondo rosado en la posición 0
con 0. Finalmente creamos la funcion if con la condición “name” debe ser igual a
“__main__”, además instanciamos la clase Tk en “ventana” e instanciamos la clase Alumno
con el parámetro “ventana” en “aplicación”, por último el el bucle principal de la ventana se
carga en la clase ventana.

8
Ejercicio 8: Copiar el programa de abajo, compilar, analizar y comentar lo que sucede.

#Crear una ventana con Tkinter

from tkinter import * # "*" para importar todas las librerías
from tkinter import ttk # libreria para los botones
class Alumno: #creamos nuestra clase
def __init__(self,ventana):
self.ventana = ventana
self.ventana.title("Hola mundo")
#Marco
#Creamos un macro llamado marco
marco=LabelFrame(self.ventana,text="Alumno")
marco.grid(row=0,column=0,columnspan=3,pady=20)
#Nombre
Label(marco,text="Nombre").grid(row=0,column=0)
Entry(marco).grid(row=0,column=1)
#Clave
Label(marco,text="Clave").grid(row=1,column=0)
Entry(marco).grid(row=1,column=1)
#Botón
ttk.Button(marco,text="Guardar alumno").grid(row=2, columnspan=2,sticky=W+E)
if __name__ == "__main__":
ventana = Tk() #Instanciamos la clase Tk()
aplicacion = Alumno(ventana) #instanciamos la clase Alumno
ventana.mainloop()

9
Comentario: En este ejercicio creamos una ventana que puede llenar registros con nuestro
nombre y apellido también nos pide clave, es como un Facebook como tipo código usamos
label para poder crear la ventana que nos dan también le dimos una clave para que
podemos ingresar a lo que hicimos en clases.

10
4. Observaciones:
• Usamos todos los objetos que cooperan entre sí cada objeto es una pequeña isla
copera con programas enteros.
• La forma de cómo proteger una información usamos varios paradigmas en la
programación orientada a objetos.
• Todas las variables tienen un tipo que expresan distintas cualidades y expresiones
para el formato.

5. Conclusiones:
• Aprendimos varios paradigmas como Abstracción, encapsulamiento, polimorfismo,
herencia.
• También el class padre para es una plantilla para crear objetos, y es una de las
formas en que se pueden implementar programación orientada a objetos (POO) en
Python.
• Es una plantilla que contiene varias estructuras básicas de un objeto la cual es
propiedad de un Objeto: Atributo o campo, Método o mensaje.

11