Que es un Objeto?

Los Objetos son todas las cosas físicas o conceptuales que tienen propiedades y comportamientos. Por ejemplo: usuario, sesión, auto, etc.

Las Propiedades o atributos son las características de nuestros objetos. Estos atributos siempre serán sustantivos y pueden tener diferentes valores que harán referencia a nombres, tamaños, formas y estados.

Por ejemplo: el color del auto es verde o rojo (color es el atributo, verde y rojo son posibles valores para este atributo).

Los Comportamientos o métodos serán todas las operaciones de nuestros objetos que solemos llamar usando verbos o sustantivos y verbos. Por ejemplo: los métodos del objeto sesión pueden ser login(), logout(), makeReport(), et

Abstracción: ¿Qué es una Clase?

La Abstracción se trata de analizar objetos de forma independiente, sus propiedades, características y comportamientos, para abstraer su composición y generar un modelo, lo que traducimos a código como clases.

Las Clases son los modelos sobre los cuales construimos nuestros objetos, es decir, las clases son los “moldes” que nos permiten generar objetos. Cada clase debe tener identidad (con un nombre de clase único usando Upper Camel Case), estado (con sus atributos) y comportamiento (con sus métodos y operaciones).

Ejemplo clase Persona

class Person :
    #Esta función se ejecuta en el momento de crear un objeto del tipo persona
    #Siempre será la función que se ejecute de primero al crear un objeto
    #a partir de una clase
    def __init__(self,nombre):
        #Self sirve para acceder y configurar los atributos de la clase
        #en este caso se define el atributo nombre, message_preview,message_walk
        self.nombre = nombre
        self.message_preview ="Hola mi nombre es {} y tengo un mensaje quedar : \n{}"
        self.message_walk="estoy dando mi paso {} y caminare hasta {} pasos"
        #Este mensaje se mostrará siempre al crear una nueva entidad persona
        print ("Soy una persona nueva, mi nombre es {}".format(self.nombre))

    def talk (self,message) :
        print (self.message_preview.format(self.nombre,message))

    def walk_n_steps(self,n_steps) :
        for i in range (n_steps) : print(self.message_walk.format (i+1,n_steps))

Clase Alien

class Alien:
    def __init__(self,nombre,planeta):
        self.nombre = nombre
        self.planeta = planeta
        self.message_preview =": radeuq ejasnem nu ognet y {} se erbmon im aloh \n{}"
        self.message_walk="yo no camino me teletransporto a la cordenada que quiera voy a {} pasos en un solo instante"
        #Este mensaje se mostrará siempre al crear una nueva entidad persona
        print ("{} atetnalp led yos {} se erbmon im ,oveun neila nu yos".format(
            self.reversed_message(self.planeta), 
            self.reversed_message(self.nombre)))
    # Pregunto al estudiante ¿como funciona esto?
    def reversed_message (self,message) :
        reversor =""
        for i in range (len(message)) :
            reversor += message[-(i+1)]
        return reversor
    def talk (self,message) :
        print (self.message_preview.format(
            self.nombre,self.reversed_message(message)))
    #podemos llamar funciones de la misma clase empleando self. nombre de la 
    #función
    def walk_n_steps(self,n_steps) :
        self.talk(self.message_walk.format (n_steps))

¿Qué es la Herencia? Don't repeat Yourself

Don’t repeat yourself (DRY) consiste en detectar cuando estamos repitiendo el mismo código una y otra vez para crear algún método o función que nos ayude a evitar estos repetidos.

Esta es una de las bases de la programación que siempre debemos tener en cuenta, ya que nos ayuda a reducir la dificultad de nuestro código para implementar cambios y/o mejoras en nuestra aplicación.

La Herencia consiste en crear nuevas clases a partir de otras clases, establecemos una relación padre e hijo entre nuestras clases. Por ejemplo supongamos que un humano se especializa en ingeniería. Este humano seguiría teniendo las mismas capacidades pero agregando unas nuevas funciones.

Clase ingeniero

#en este caso supongamos que un humano se especializó en
#ingenieria
import PersonEntity.Person as pers

class Engineer (pers.Person) :
    def __init__(self, nombre,profesion):
        self.profesion = profesion
        self.mensaje_humilde = "somos parecidos en habilidad mental por eso puedo decir que habla, el dice : {}"


    def reversed_message (self,message) :
        reversor =""
        for i in range (len(message)) :
            reversor += message[-(i+1)]
        return reversor

    def translate_alien (self,alienmessage) :
        print(self.mensaje_humilde.format(
            self.reversed_message(alienmessage)))

Empleando las clases

En este caso podemos ver cómo empleamos, las clases en un archivo central. Recuerden observar la sesión 7 para tener claridad de los archivos

import PersonEntity.Person as Per
import AlienEntity.Alien as Ali
import PersonEntity.Engineer as eng

alien_mensaje = "etnatsni olos nu ne sosap 4 a yov areiuq euq adanedroc al a otropsnartelet em onimac on oy"
#Al igual que las funciones se deben importar
#no obstante deben iniciarse con las variables 
#configuradas en el init, por eso para el caso de persona
#solo require del nombre
#Y del alien pide el nombre y el planeta
mafer = Per.Person ("mafer")
mafer.talk("Esto realmente funciona muy bien")
mafer.walk_n_steps (4)
rodolfo = Ali.Alien("rodolfo", "marte")
rodolfo.talk ("yo hablo al contrario de lo que crees")
rodolfo.walk_n_steps(4)
daniel = eng.Engineer("daniel", "ingenierio biomédico")
daniel.translate_alien (alien_mensaje)