Aprendizajes esenciales o competencias esenciales 1° parcial




                                                                                                                                                                                                                                                                


Dirección GeneraldeEducación Tecnológica Industrial  y de Servicios

Dirección Académica e Innovación Educativa

Subdirección de Innovación Educativa

Departamento de Planes, Programas y Superación Académica





Cuadernillo de Aprendizajes Esenciales, Estrategias de Aprendizaje y Productos


Programación


     

ubsecretaría de Educación Media Superior 

Dirección General de Educación Tecnológica Industrial y de Servicios 

Dirección Académica e Innovación Educativa

Subdirección de Innovación Académica




Aprendizajes esenciales

Carrera:

Programación

Semestre:

3


Módulo/Submódulo:


Módulo II. Aplica Metodologías de Desarrollo de Software con Herramientas de Programación Visual. Submódulo 1: Aplica metodología espiral con programación orientada a objetos

Aprendizajes esenciales o Competencias esenciales 1er parcial

Estrategias de Aprendizaje

Productos a Evaluar

I.- Identifica los elementos del paradigma de la programación orientada a objetos

Paradigma: Es el método de como el programador encuentra la solución al problema. 


1.- Aplica los conceptos de clases y objetos

  1. El estudiante resuelve el Cuestionario Conceptos básicos

Cuestionario: Conceptos básicos

  1. ¿Qué es un paradigma?

Es la metodología y referencia para que el programador pueda resolver el problema. Ejemplo los estilos de programación como la orientada a objetos, la funcional, imperativa y la declarativa y la lógica. 

  1. ¿Qué entiende por programación orientada a objetos?

Es un estilo de programación donde se utilizan objetos y que cada uno tiene propiedades, estos objetos sirven que el código sea más pequeño y fácil de editar  

  1. ¿Conoces los elementos de la programación orientada a objetos y si es así cuáles son?

La abstracción es el proceso de simplificar la complejidad de los sistemas mostrado solo los detalles esenciales, la complejidad es la dificultad del sistema del programa y cómo se comporta, la herencia es la habilidad de una subclase tener aspectos de la clase madre y así reutilizar de mejor manera el código y polimorfismo es la habilidad de los objetos que sean tratados como si fuera de una misma superclase 

  1. ¿Qué beneficios obtienes al emplear la programación orientada a objetos?

Un código más optimizado y que se puede actualizar de manera más rápida 


Fuente: https://www.youtube.com/watch?v=AgygnnMaxC8


1.1 Cuestionario Conceptos básicos



  1. El estudiante elabora un resumen de los conceptos principales del paradigma orientado a objetos a partir de las lecturas sugeridas por el docente.


La programación orientada a objetos es un estilo de programación donde el código se reparte por objetos que contiene varias clases y estas son indispensables para reutilizar el código, el paradigma de este estilo es principalmente el objeto que en la mayoría de las veces es un conjunto de código que realizar una acción y que contiene características y puede agrupar datos y comportamientos y que toda esta información es reutilizable y de ahí la principal función de este estilo de programación y como se reutilizar partes del código y esto se consigue con la subclases que contienen la característica de heredar aspectos de una clase y reutilizar esa parte del código. 

  


1.2 Resumen de conceptos principales del paradigma orientado a objetos


  1. El estudiante identifica en su entorno cotidiano los principales conceptos del paradigma orientado a objetos, los registra en un cuadro y redacta una definición propia de los conceptos de forma simple y entendible.


Clase: Es el modelo que se sigue para que un objeto tenga atributos y sean definidos y concisos. Ejemplo un valor es un modelo a seguir para una persona por lo que quera replicarlo en la vida y así es como 


Objeto: Es un tipo de entidad con características y comportamientos y debe de cumplir una función, puede estar basado en algo de la realidad. 


Complejidad: Son las dificultades que puede presentar el código y que este no sea lo deseado. Ejemplo es cuando intentamos resolver un problema sin atentes contemplar las opciones y tropiezos.

1.3 Cuadro de identificación de conceptos y su definición personal


  1. Investiga en los documentos proporcionados por el docente, la estructura de una clase y crear al menos 3 clases de los ejemplos proporcionados en la investigación de su entorno personal, registrando en su cuaderno de trabajo la estructura de cada uno de ellos.


Clase 1  

Nombre: Salón de clase


Atributos: Espacio, capacidad, núm. De ventanas, puerta, color, cantidad de bancas, escritorio, limpieza y miembros


Métodos y eventos: clase, entrada y salida de personas, mantenimiento, suciedad, falta de elementos y daños 


Clase 2 

Nombre: libreta


Atributos: dimensión, cantidad de hojas, color de la cubierta, tipo de hoja, tipo de espiral, grosor de la cubierta, material de la cubierta, diseño en la cubierta


Métodos y eventos: abrir libreta, cerrar libreta, escribir en la libreta, dibujar, garabatear, coloca algo encima, se lanza, se golpea, se moja, se rompe, se ensucia, se modifica y si se dobla.


Clase 3 

Nombre: árbol 


Atributos: Color de hojas. Color de madera, altura, volumen, anchura, tipo de madera, frutos y tamaño de hojas


Métodos y eventos: talado, podado, quemado, mojado, contaminado, maltrato y deformación. 


1.4 Redacción de tres ejemplos de clase con su respectiva estructura


  1. De los ejemplos de clase elaborados, selecciona uno, y escribe cuáles serían los comportamientos que pudiese tener el objeto creado.


Seria la libreta, los comportamientos seria que en mi caso mi libreta tendría u color y una textura diferente a otra libreta de una materia diferente, si se escribe o se dibuja su comportamiento cambaría ya que por el desgaste las escrituras saldrían manchadas o con texturas no deseada, otro comportamiento seria la resistencia ante diferentes circunstancias.  


1.5 Descripción del comportamiento

2

            




 

                                                                            Subsecretaría de Educación Media Superior 

                                        

Dirección General de Educación Tecnológica Industrial y de Servicios 

Dirección Académica e Innovación Educativa

Subdirección de Innovación Académica






  1. Diseña, en su cuaderno de trabajo, clases relacionadas a objetos de su entorno considerando únicamente la identificación de los atributos del objeto e implementar las clases en un lenguaje de programación orientado a objetos.


Clase.


Nombre: Plato


Atributos: Material, ancho, largo, profundidad, capacidad, uso, color, diseño y resistencia.


Ejemplo en un lenguaje de programación.

class Plato:

    def __init__(self, material, ancho, largo, profundidad, capacidad, uso, color, diseno, resistencia):

        self.material = material

        self.ancho = ancho

        self.largo = largo

        self.profundidad = profundidad

        self.capacidad = capacidad

        self.uso = uso

        self.color = color

        self.diseno = diseno

        self.resistencia = resistencia


    def mostrar_informacion(self):

        print("=== Información del Plato ===")

        print(f"Material: {self.material}")

        print(f"Ancho: {self.ancho} cm")

        print(f"Largo: {self.largo} cm")

        print(f"Profundidad: {self.profundidad} cm")

        print(f"Capacidad: {self.capacidad} ml")

        print(f"Uso: {self.uso}")

        print(f"Color: {self.color}")

        print(f"Diseño: {self.diseno}")

        print(f"Resistencia: {self.resistencia}")

Fuente: https://www.youtube.com/watch?v=9x7RK6mb1uA


  1. Diseña clases protegiendo los datos con modificadores de acceso privado o protegido y agregar métodos públicos para obtener acceso seguro a los mismos.


class Plato:

    def __init__(self, material, ancho, largo, profundidad, capacidad, uso, color, diseno, resistencia):

        # Atributos privados

        self.__material = material

        self.__ancho = ancho

        self.__largo = largo

        self.__profundidad = profundidad

        self.__capacidad = capacidad

        self.__uso = uso

        self.__color = color

        self.__diseno = diseno

        self.__resistencia = resistencia


    # ==== MÉTODOS GETTERS (acceso seguro a los atributos) ====

    def get_material(self):

        return self.__material


    def get_ancho(self):

        return self.__ancho


    def get_largo(self):

        return self.__largo


    def get_profundidad(self):

        return self.__profundidad


    def get_capacidad(self):

        return self.__capacidad


    def get_uso(self):

        return self.__uso


    def get_color(self):

        return self.__color


    def get_diseno(self):

        return self.__diseno


    def get_resistencia(self):

        return self. __resistencia


    # ==== MÉTODOS SETTERS (modificación controlada) ====

    def set_uso(self, nuevo_uso):

        if nuevo_uso.strip() != "":

            self.__uso = nuevo_uso

        else:

            print(" Error: El uso no puede estar vacío.")


    def set_color(self, nuevo_color):

        if nuevo_color.strip() != "":

            self.__color = nuevo_color

        else:

            print(" Error: El color no puede estar vacío.")


    # Método para mostrar toda la información

    def mostrar_informacion(self):

        print("=== Información del Plato ===")

        print(f"Material: {self.get_material()}")

        print(f"Ancho: {self.get_ancho()} cm")

        print(f"Largo: {self.get_largo()} cm")

        print(f"Profundidad: {self.get_profundidad()} cm")

        print(f"Capacidad: {self.get_capacidad()} ml")

        print(f"Uso: {self.get_uso()}")

        print(f"Color: {self.get_color()}")

        print(f"Diseño: {self.get_diseno()}")

        print(f"Resistencia: {self.get_resistencia()}")



# ==== Ejemplo de uso ====

if __name__ == "__main__":

    plato1 = Plato("Cerámica", 25, 25, 3, 500, "Comida principal", "Blanco", "Liso", "Alta")


    # Mostramos datos iniciales

    plato1.mostrar_informacion()


    # Accedemos de manera segura con getters

    print ("\nEl color actual es:", plato1.get_color ())


    # Cambiamos color y uso con setters

    plato1.set_color("Azul")

    plato1.set_uso("Postres")


    print ("\nDespués de modificaciones seguras:")

    plato1.mostrar_informacion()



Modificadores de acceso privado: los modificadores ayudan que si se hace un programa con datos personales no sean visibles hacia el exterior del objeto, los atributos y métodos son accesibles especificando el objeto (instancia de una clase) seguido de un punto y el elemento al que se refiere (atributo o método).


Fuente: 

https://www.youtube.com/watch?v=uM6GD_gg6oY


https://portalacademico.cch.unam.mx/cibernetica2/principios-programacion-orientada-a-objetos/modificadores-de-acceso




  1. En base a lo ya realizado deberá realizar un programa práctico empleando un lenguaje de programación.

class Plato:

    def __init__(self, material, ancho, largo, profundidad, capacidad, uso, color, diseno, resistencia):

        # Atributos privados

        self.__material = material

        self.__ancho = ancho

        self.__largo = largo

        self.__profundidad = profundidad

        self.__capacidad = capacidad

        self.__uso = uso

        self.__color = color

        self.__diseno = diseno

        self.__resistencia = resistencia


    # === Propiedades con @property ===

    @property

    def material(self):

        return self.__material


    @property

    def ancho(self):

        return self.__ancho


    @property

    def largo(self):

        return self.__largo


    @property

    def profundidad(self):

        return self. __profundidad


    @property

    def capacidad(self):

        return self. __capacidad


    @property

    def uso(self):

        return self.__uso


    @uso.setter

    def uso(self, nuevo_uso):

        self.__uso = nuevo_uso


    @property

    def color(self):

        return self.__color


    @color.setter

    def color(self, nuevo_color):

        self.__color = nuevo_color


    @property

    def diseno(self):

        return self.__diseno


    @property

    def resistencia(self):

        return self.__resistencia


    # Método para mostrar la información

    def mostrar_informacion(self):

        print("=== Información del Plato ===")

        print(f"Material: {self.material}")

        print(f"Ancho: {self.ancho} cm")

        print(f"Largo: {self.largo} cm")

        print(f"Profundidad: {self.profundidad} cm")

        print(f"Capacidad: {self.capacidad} ml")

        print(f"Uso: {self.uso}")

        print(f"Color: {self.color}")

        print(f"Diseño: {self.diseno}")

        print(f"Resistencia: {self.resistencia}")


Fuente

https://www.youtube.com/watch?v=uM6GD_gg6oY


  1. Práctica realizada




  1. Práctica realizada




  1. Programa realizado

2. Utiliza las propiedades de herencia y polimorfismo

  1. Crea clases que reúnan los miembros necesarios para resolver un problema y así implementar el encapsulamiento.


Clase Estudiante

  • Atributos privados (ocultos):

  • Nombre

  • Edad

  • Calificación

  • Métodos públicos (interacción segura):

  • Ver nombre

  • Ver edad

  • Cambiar calificación (solo si es un número válido)

Clase: Es una especie de plantilla con características en las que se utilizara para crear nuestro objeto.

 

Fuente: https://newsletter.cuarzo.dev/p/que-es-una-clase-en-programacion




  1. Identifica la estructura de un método y crea un programa que permita su uso en la resolución de problemas específicos.


La estructura de un método se compone principalmente de una cabecera y un cuerpo, la cabecera incluye el modificador de acceso, el tipo de retorno, el nombre del método y su lista de parámetros. El cuerpo es un bloque de código entre llaves que contiene las instrucciones.


Ejemplo: 

class Rectangulo:

    def __init__(self, base, altura):

        # Atributos privados

        self.__base = base

        self.__altura = altura


    # Método para calcular el área

    def calcular_area(self):

        return self.__base * self.__altura


    # Métodos para acceder de forma segura

    def get_base(self):

        return self.__base

    

    def get_altura(self):

        return self.__altura

    

    def set_base(self, nueva_base):

        if nueva_base > 0:

            self.__base = nueva_base

        else:

            print("La base debe ser mayor a 0.")


    def set_altura(self, nueva_altura):

        if nueva_altura > 0:

            self.__altura = nueva_altura

        else:

            print("La altura debe ser mayor a 0.")



# Uso del programa

rect = Rectangulo(10, 5)

print(f"Base: {rect.get_base()}, Altura: {rect.get_altura()}")

print("Área del rectángulo:", rect.calcular_area())


# Cambiar valores con los métodos

rect.set_base(12)

rect.set_altura(6)

print(f"Nueva Base: {rect.get_base()}, Nueva Altura: {rect.get_altura()}")

print("Nuevo área del rectángulo:", rect.calcular_area())

  1. Crea programas que contengan métodos sobrecargados y probar la utilidad de dichos métodos empleando herencia y polimorfismo.

Herencia: Cuando se crean subclases y que estas contienen parte de la clase que proporciona estas características 


Polimorfismo: Se refiere a que los objetos en programación, aunque sean diferentes estos compartan características y comportamientos.


Fuente: https://es.wikipedia.org/wiki/Polimorfismo_(inform%C3%A1tica)#:~:text=En%20programaci%C3%B3n%20orientada%20a%20objetos,en%20el%20dise%C3%B1o%20del%20software.


 https://www.dongee.com/tutoriales/que-es-herencia-en-programacion/#:~:text=La%20herencia%20en%20programaci%C3%B3n%20es,funcionalidad%20de%20la%20clase%20original.


  1. Elabora reporte de prácticas.

Las prácticas nos indican como se desarrollan programas utilizando la metodología de POO aquí se utilizo el lenguaje de Python por su sencillez y forma de escritura de mejor comprensión para cada programa. 

Durante las practicas se exploraron diversos problemas o situaciones con respuestas sencillas y sin tanta complejidad , aunque también es importante identificar a fondo el como resolver el problema de la manera mas fácil.



  1. Elabora un cuadro sinóptico en el que se muestren las definiciones de herencia y su clasificación.













  1. Realiza la siguiente actividad:

    • Identifica los atributos y comportamientos propios de una especie que comparten los animales pertenecientes a ella.

    • Identifica los atributos y comportamientos propios de una categoría de objetos que compartan todos sus miembros.

Con los datos obtenidos crea programas prácticos que manejen el concepto de herencia implementando redefinición de constructores y métodos.


class Electrodomestico:

    def __init__(self, marca, modelo, consumo):

        self.marca = marca

        self.modelo = modelo

        self.consumo = consumo  # Consumo en kWh


    def encender(self):

        return "El electrodoméstico está encendido."


    def mostrar_info(self):

        return f"Electrodoméstico → Marca: {self.marca}, Modelo: {self.modelo}, Consumo: {self.consumo} kWh"



class Lavadora(Electrodomestico):

    def __init__(self, marca, modelo, consumo, capacidad):

        super().__init__(marca, modelo, consumo)  # Reutiliza atributos de Electrodomestico

        self.capacidad = capacidad  # kg de ropa


    def encender(self):  # Redefinición de método

        return "La lavadora inicia el ciclo de lavado."


    def mostrar_info(self):

        return f"Lavadora → Marca: {self.marca}, Modelo: {self.modelo}, Consumo: {self.consumo} kWh, Capacidad: {self.capacidad} kg"



class Refrigerador(Electrodomestico):

    def __init__(self, marca, modelo, consumo, puertas):

        super().__init__(marca, modelo, consumo)

        self.puertas = puertas  # Número de puertas


    def encender(self):  # Redefinición de método

        return "El refrigerador empieza a enfriar."


    def mostrar_info(self):

        return f"Refrigerador → Marca: {self.marca}, Modelo: {self.modelo}, Consumo: {self.consumo} kWh, Puertas: {self.puertas}"



# Uso del programa

lavadora = Lavadora("LG", "TurboWash", 1.5, 10)

refrigerador = Refrigerador("Samsung", "CoolMax", 0.8, 2)


print(lavadora.mostrar_info())

print(lavadora.encender())


print(refrigerador.mostrar_info())

print(refrigerador.encender())


  1. Práctica realizada.



  1. Ejercicio realizado.



  1. Código de los Programas realizados.



  1. Portafolio de Evidencia de Prácticas.



  1. Cuadro sinóptico de herencia y clasificación


  1. Programas Realizados.

Comentarios

Publicar un comentario