Programacion Orientada a Objetos.

Python

La Programación Orientada a Objetos (POO) es un paradigma de programación que utiliza objetos y sus interacciones para diseñar aplicaciones y programas de computadora. Está basado en varias técnicas, incluyendo herencia, encapsulación, polimorfismo y abstracción.

Su sintaxis es más clara y sencilla de entender que otros paradigmas de programación. Al permitirnos modelar entidades del mundo real de forma más directa.

Ejemplo:

class Coche:
    def __init__(self, marca, modelo, color):
        self.marca = marca
        self.modelo = modelo
        self.color = color

    def acelerar(self):
        print(f"El coche {self.marca} {self.modelo} de color {self.color} está acelerando")

    def frenar(self):
        print(f"El coche {self.marca} {self.modelo} de color {self.color} está frenando")

    def __str__(self):
        return f"Coche {self.marca} {self.modelo} de color {self.color}"

En el código anterior se define una clase Coche con tres atributos marca, modelo y color. Además, se definen tres métodos acelerar, frenar y str. El método str es un método especial que se llama cuando se convierte un objeto a una cadena de texto.

Para crear un objeto de la clase Coche se hace de la siguiente manera:

coche = Coche("Toyota", "Corolla", "Rojo")
print(coche)
coche.acelerar()
coche.frenar()

En el código anterior se crea un objeto coche de la clase Coche con los atributos Toyota, Corolla y Rojo. Luego se imprime el objeto coche y se llama a los métodos acelerar y frenar.

Objetos y Clases

Los objetos son instancias de una clase. Una clase es una plantilla para crear objetos. Los objetos tienen atributos y métodos.

Atributos

Los atributos son variables que pertenecen a un objeto. Los atributos pueden ser de cualquier tipo de datos.

Ejemplo:

class Coche:
    def __init__(self, marca, modelo, color):
        self.marca = marca
        self.modelo = modelo
        self.color = color

En el código anterior se definen tres atributos marca, modelo y color.

¿Qué es self?

Self es una palabra reservada en Python que se refiere al objeto actual. Se utiliza para acceder a los atributos y métodos de un objeto.

En el ejemplo anterior, self.marca, self.modelo y self.color se refieren a los atributos de un objeto.

Ejemplo:

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
    def saludar(self):
        print(f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años")

En el ejemplo anterior se define una clase Persona con dos atributos nombre y edad. Además, se define un método saludar que imprime un mensaje con los atributos nombre y edad.

Métodos

Los métodos son funciones que pertenecen a un objeto. Los métodos pueden acceder a los atributos de un objeto.

Ejemplo:

class Coche:
    def acelerar(self):
        print(f"El coche {self.marca} {self.modelo} de color {self.color} está acelerando")

    def frenar(self):
        print(f"El coche {self.marca} {self.modelo} de color {self.color} está frenando")

En el código anterior se definen dos métodos acelerar y frenar.

Self, Eliminar Propiedades y Objetos

El primer parámetro de un método es self. Self es una referencia al objeto actual. Se utiliza para acceder a los atributos y métodos de un objeto.

Ejemplo:

class Coche:
    def __init__(self, marca, modelo, color):
        self.marca = marca
        self.modelo = modelo
        self.color = color

    def acelerar(self):
        print(f"El coche {self.marca} {self.modelo} de color {self.color} está acelerando")

    def frenar(self):
        print(f"El coche {self.marca} {self.modelo} de color {self.color} está frenando")

    def __del__(self):
        print(f"El coche {self.marca} {self.modelo} de color {self.color} ha sido eliminado")

coche = Coche("Toyota", "Corolla", "Rojo")
print(coche)
coche.acelerar()
coche.frenar()
del coche

En el código anterior se define un método especial del que se llama cuando un objeto es eliminado. Luego se crea un objeto coche de la clase Coche y se elimina el objeto coche.

Por otra parte la palabra reservada self se utiliza para acceder a los atributos y métodos de un objeto.

Tambien se está creando una instancia de la clase Coche y se está eliminando el objeto coche.

Eliminar Propiedades y Objetos

Para eliminar Propiedades y Objetos se utiliza la palabra reservada del.

Como observamos en el código anterior la propiedad del se utiliza para eliminar un objeto.

Ejemplo:

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
    def __del__(self):
        print(f"La persona {self.nombre} ha sido eliminada")

persona = Persona("Juan Perez", 30)
print(persona)
del persona

En el código anterior se define un método especial del que se llama cuando un objeto es eliminado. Luego se crea un objeto persona de la clase Persona y se elimina el objeto persona. Al final obtendremos un mensaje como este:

La persona Juan Perez ha sido eliminada

Herencia, Polimorfismo y Encapsulación

Herencia

La herencia es una característica de la POO que permite crear una nueva clase a partir de una clase existente. La nueva clase hereda los atributos y métodos de la clase existente.

Ejemplo:

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre
    def hablar(self):
        pass

class Perro(Animal):
    def hablar(self):
        print(f"{self.nombre} dice guau")

class Gato(Animal):
    def hablar(self):
      print(f"{self.nombre} dice miau")


animal = Perro("Firulais")
animal2 = Gato("Garfield")

En el código anterior se define una clase Animal con un método hablar. Luego se definen dos clases Perro y Gato que heredan de la clase Animal y sobrescriben el método hablar.

Polimorfismo

El polimorfismo es una característica de la POO que permite que un objeto se computadora de diferentes maneras dependiendo del contexto.

Ejemplo:

class Deporte:
    def jugar(self):
        pass

class Futbol(Deporte):
    def jugar(self):
        print(f"Jugando futbol")

class Baloncesto(Deporte):
    def jugar(self):
      print(f"Jugando baloncesto")

class Tenis(Deporte):
    def jugar(self):
      print(f"Jugando tenis")

deporte = Futbol()
deporte.jugar()

deporte1 = Baloncesto()
deporte1.jugar()

deporte2 = Tenis()
deporte2.jugar()

En el ejemplo anterior se define una clase Deporte con un método jugar. Luego se definen tres clases Futbol, Baloncesto y Tenis que heredan de la clase Deporte y sobrescriben el método jugar. Aunque los tres objetos son de la clase Deporte, se comportan de manera diferente.

Encapsulación

La encapsulación es una característica de la POO que permite ocultar los detalles de implementación de un objeto. Los atributos y métodos de un objeto pueden ser públicos, protegidos o privados.

Ejemplo:

class CuentaBancaria:
    def __init__(self, nombre, saldo):
        self.nombre = nombre
        self.__saldo = saldo  # El saldo es privado

    def depositar(self, cantidad):
        self.__saldo += cantidad

    def retirar(self, cantidad):
        if cantidad <= self.__saldo:
            self.__saldo -= cantidad
        else:
            print("Fondos insuficientes")

    def obtener_saldo(self):
        return self.__saldo  # Método para acceder al saldo

    def __str__(self):
        return f"Cuenta Bancaria de {self.nombre} con saldo {self.__saldo}"


# Creación de instancias de cuentas bancarias
cuenta1 = CuentaBancaria("Juan Perez", 1000)
cuenta2 = CuentaBancaria("Maria Lopez", 2000)
cuenta3 = CuentaBancaria("Pedro Ramirez", 3000)

# Operaciones en las cuentas
cuenta1.depositar(500)
cuenta1.retirar(200)
print(cuenta1.nombre)
print(cuenta1.obtener_saldo())  # Acceso al saldo a través de un método

print(cuenta2.nombre)
cuenta2.depositar(500)
cuenta2.retirar(200)
print(cuenta2.obtener_saldo())

print(cuenta3.nombre)
cuenta3.depositar(1000)
cuenta3.retirar(500)
print(cuenta3.obtener_saldo())

La encapsulación es un principio fundamental en la programación orientada a objetos que permite proteger los datos de un objeto. En Python, se logra utilizando variables privadas y métodos de acceso para controlar cómo se accede y modifica la información dentro de una clase.

En el ejemplo de CuentaBancaria, el atributo saldo es privado (indicado por el prefijo ) y no puede ser accedido directamente desde fuera de la clase. Esto significa que no se puede escribir cuenta1.__saldo para leer o modificar el saldo.

Para interactuar con el saldo de manera segura, la clase proporciona métodos públicos como depositar y retirar, que permiten modificar el saldo solo bajo condiciones controladas. En este caso, se agregó un método obtener_saldo para acceder al saldo de manera segura. Este enfoque evita que se altere el saldo de forma indebida y permite implementar lógica adicional, como verificar si hay fondos suficientes antes de retirar una cantidad.

Este ejemplo demuestra cómo la encapsulación ayuda a proteger y controlar el acceso a los datos de un objeto, asegurando que su estado interno se gestione correctamente.

Actividad

Crear una clase Persona con los atributos nombre, edad y sexo.
Crear una clase Estudiante que herede de la clase Persona con los atributos carnet y carrera.
Crear una clase Profesor que herede de la clase Persona con los atributos codigo y especialidad.
Crear una clase Curso con los atributos nombre, codigo y profesor.
Crear una clase Universidad con los atributos nombre y cursos.
Crear un objeto universidad de la clase Universidad con el nombre Universidad de El Salvador y los siguientes cursos:

Curso 1: Nombre: Matematicas, Codigo: MAT101, Profesor: Juan Perez
Curso 2: Nombre: Fisica, Codigo: FIS101, Profesor: Maria Lopez
Curso 3: Nombre: Quimica, Codigo: QUI101, Profesor: Pedro Ramirez

Imprimir el objeto universidad.
Crear un objeto estudiante de la clase Estudiante con los siguientes atributos:

Nombre: Carlos Perez
Edad: 20
Sexo: Masculino
Carnet: 202010101
Carrera: Ingenieria en Sistemas Informaticos

Imprimir el objeto estudiante.
Crear un objeto profesor de la clase Profesor con los siguientes atributos:

Nombre: Juan Perez
Edad: 30
Sexo: Masculino
Codigo: 202020202
Especialidad: Matematicas

Imprimir el objeto profesor.
Crear un objeto curso de la clase Curso con los siguientes atributos:

Nombre: Matematicas
Codigo: MAT101
Profesor: Juan Perez

Imprimir el objeto curso.
Agregar el objeto curso al objeto universidad.
Imprimir el objeto universidad.
Crear un objeto curso de la clase Curso con los siguientes atributos:

Nombre: Fisica
Codigo: FIS101
Profesor: Maria Lopez

Respuesta

class Persona:
    def __init__(self, nombre, edad, sexo):
        self.nombre = nombre
        self.edad = edad
        self.sexo = sexo

class Estudiante(Persona):
    def __init__(self, nombre, edad, sexo, carnet, carrera):
        super().__init__(nombre, edad, sexo)
        self.carnet = carnet
        self.carrera = carrera

class Profesor(Persona):
    def __init__(self, nombre, edad, sexo, codigo, especialidad):
        super().__init__(nombre, edad, sexo)
        self.codigo = codigo
        self.especialidad = especialidad

class Curso:
    def __init__(self, nombre, codigo, profesor):
        self.nombre = nombre
        self.codigo = codigo
        self.profesor = profesor

class Universidad
    def __init__(self, nombre):
        self.nombre = nombre
        self.cursos = []

universidad = Universidad("Universidad de las Fuerzas Armadas ESPE")
curso1 = Curso("Matematicas", "MAT101", "Juan Perez")
curso2 = Curso("Fisica", "FIS101", "Maria Lopez")
curso3 = Curso("Quimica", "QUI101", "Pedro Ramirez")
universidad.cursos.append(curso1)
universidad.cursos.append(curso2)
universidad.cursos.append(curso3)
print(universidad)

estudiante = Estudiante("Carlos Perez", 20, "Masculino", "202010101", "Ingenieria en Sistemas Informaticos")
print(estudiante)

profesor = Profesor("Juan Perez", 30, "Masculino", "202020202", "Matematicas")
print(profesor)

curso = Curso("Matematicas", "MAT101", "Juan Perez")
print(curso)

curso = Curso("Fisica", "FIS101", "Maria Lopez")
universidad.cursos.append(curso)
print(universidad)

Objetos y Clases

Atributos

¿Qué es self?

Métodos

Self, Eliminar Propiedades y Objetos

Eliminar Propiedades y Objetos

Herencia, Polimorfismo y Encapsulación

Herencia

Polimorfismo

Encapsulación

Actividad

Conclusiones